home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DBio / DSeqPrint.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  83.6 KB  |  2,997 lines  |  [TEXT/R*ch]
  1. // DSeqPrint.cpp
  2. // d.g.gilbert, 1991-95
  3.  
  4. #define MASKS 1
  5.  
  6. #include "DSequence.h"
  7. #include "DSeqList.h"
  8. #include "DSeqDoc.h"
  9. #include "DSeqPrint.h"
  10. #include "DREnzyme.h"
  11.  
  12. #include <ncbi.h>
  13. #include <dgg.h>
  14. #include <Dvibrant.h>
  15. #include <DControl.h>
  16. #include <DDialogText.h>
  17. #include <DWindow.h>
  18. #include <DTableView.h>
  19. #include <DApplication.h>
  20. #include <DTask.h>
  21. #include <DTracker.h>
  22. #include <DMenu.h>
  23. #include <DUtil.h>
  24.  
  25.  
  26. enum FonStyles { 
  27.     kPlain = 0, kItalic = 1, kBold = 2, kUnderline = 4 
  28.     };
  29.  
  30.  
  31. enum {
  32.  
  33.     kShadeInvert = 1,
  34.     kShadeGray50 = 2,
  35.     kShadeGray25 = 3,
  36.     kShadeGray75 = 4,
  37.     kShadeStipple50    = 5,
  38.     kShadeStipple25    = 6,
  39.     kShadeStipple75    = 7,
  40.     
  41.     mColorButHit = 1001,
  42.     mMonoButHit    = 1002,
  43.  
  44.     kFontDescent = 2,
  45.     kIndexRise = 1,
  46.  
  47.   kNameWidth  = 80,
  48.   kIndexWidth = 40,
  49.   kItemWidth  = 12,
  50.     kNucSpace     = 0, //was 2
  51.     kBasesPerLine = 60, // was 50
  52.   //kSeqWidth = kItemWidth * kBasesPerLine,
  53.     kNucBorder    = 6,
  54.     kSeqLinesPerParag = 5,
  55.     kLinesPerParag= 7, // kSeqLinesPerParag + 2; // 5 seq + top index + top spacer
  56.  
  57.     kMacdrawHeaderSize= 512
  58.     };
  59.  
  60. enum SeqRowType { kSpacer, kTopline, kSeqline };
  61.  
  62.  
  63. #if 0
  64.  
  65. #define  ShadeInvert()  { PaintRect(myRect);    TextMode(srcBIC); }
  66.  
  67.                     kShadeInvert: BEGIN
  68.                         PaintRect(myRect); 
  69.                         TextMode(srcBIC);
  70.                         END;
  71. #endif
  72.  
  73.  
  74.  
  75.  
  76. class DSeqPrintPrefs : public DWindow {
  77. public:
  78.     enum { 
  79.             kSeqPrintPrefID = 1232,
  80.             kStylePlain,kStyleItalic,kStyleBold,kStyleUnderline,
  81.             cIndexLeft, cIndexRight, cIndexTop, 
  82.             cNameLeft, cNameRight,
  83.             cColored,
  84.             cShowComplement,cThreeLetAA,cOnlyORF,
  85.             cShowAA1,cShowAA2,cShowAA3,
  86.             cShowCompAA1,cShowCompAA2,cShowCompAA3,
  87.             cShowCutpoints,cShowAllZymes,cShowExcludedCutters,cShowNoncutters
  88.             };
  89.  
  90.     static char *gNameFontName, *gBaseFontName, *gIndexFontName;
  91.     static Nlm_FonT    gNameFont, gBaseFont, gIndexFont;
  92.     static short gNameFontSize, gBaseFontSize, gIndexFontSize;
  93.     static short gNameStyle, gBaseStyle, gIndexStyle;
  94.     static Boolean gNameLeft,gNameRight,gIndexLeft,gIndexRight,gIndexTop, gColored;
  95.     static short gBasesPerLine;
  96.         // restmap prefs ..
  97.     static Boolean  gShowComplement,gThreeLetAA, gOnlyORF,
  98.                 gShowAA1,gShowAA2,gShowAA3,
  99.                 gShowCompAA1,gShowCompAA2,gShowCompAA3,
  100.                 gShowAllZymes,gShowCutpoints,gShowExcludedCutters,gShowNoncutters;
  101.     static short    gREMinCuts, gREMaxCuts;
  102.     
  103.     static void InitGlobals();
  104.     static void SaveGlobals();
  105.  
  106.     DPopupMenu  * fNameFontMenu, * fBaseFontMenu, *fIndexFontMenu,
  107.                             * fNameStyleMenu, *fBaseStyleMenu, *fIndexStyleMenu;
  108.     DSwitchBox    * fNameSizeSw, * fBaseSizeSw, *fIndexSizeSw;
  109.     DEditText        * fREMinCuts, * fREMaxCuts, * fBasePerLine;
  110.     Boolean             fNeedSave;
  111.     
  112.     DSeqPrintPrefs();
  113.     virtual ~DSeqPrintPrefs();
  114.     virtual void Initialize();
  115.     virtual void Open();
  116.     virtual void Close();
  117.     virtual void OkayAction();
  118.     virtual Boolean IsMyAction(DTaskMaster* action); 
  119.     virtual void NewFontCluster(char* title, DView* mainview,
  120.                     DPopupMenu*& mfont, DPopupMenu*& mstyle, DSwitchBox*& swsize,
  121.                     char* fontname, short fontstyle, short fontsize );
  122.                     
  123. };
  124.  
  125. Global DSeqPrintPrefs* gSeqPrintPrefs = NULL;
  126.  
  127. char* DSeqPrintPrefs::gNameFontName = (char*) "times";
  128. char* DSeqPrintPrefs::gBaseFontName = (char*) "courier";
  129. char* DSeqPrintPrefs::gIndexFontName = (char*) "times";
  130. Nlm_FonT 
  131.             DSeqPrintPrefs::gNameFont = NULL, 
  132.              DSeqPrintPrefs::gBaseFont = NULL, 
  133.           DSeqPrintPrefs::gIndexFont = NULL;
  134. short 
  135.             DSeqPrintPrefs::gNameFontSize = 10, 
  136.             DSeqPrintPrefs::gBaseFontSize = 10, 
  137.             DSeqPrintPrefs::gIndexFontSize = 9,
  138.             DSeqPrintPrefs::gNameStyle = 0,  
  139.             DSeqPrintPrefs::gBaseStyle = 0,  
  140.             DSeqPrintPrefs::gIndexStyle = 0;
  141. Boolean     
  142.             DSeqPrintPrefs::gNameLeft = false,
  143.             DSeqPrintPrefs::gNameRight = true,
  144.             DSeqPrintPrefs::gIndexLeft = true,
  145.             DSeqPrintPrefs::gIndexRight = false,
  146.             DSeqPrintPrefs::gIndexTop = true, 
  147.             DSeqPrintPrefs::gColored = true;
  148.  
  149.     // restmap prefs ..
  150. Boolean  
  151.             DSeqPrintPrefs::gShowComplement = true,
  152.             DSeqPrintPrefs::gThreeLetAA = false,
  153.             DSeqPrintPrefs::gOnlyORF = false,
  154.             DSeqPrintPrefs::gShowAA1 = false,
  155.             DSeqPrintPrefs::gShowAA2 = false,
  156.             DSeqPrintPrefs::gShowAA3 = false,
  157.             DSeqPrintPrefs::gShowCompAA1 = false,
  158.             DSeqPrintPrefs::gShowCompAA2 = false,
  159.             DSeqPrintPrefs::gShowCompAA3 = false,
  160.             DSeqPrintPrefs::gShowAllZymes = false,
  161.             DSeqPrintPrefs::gShowCutpoints = false,
  162.             DSeqPrintPrefs::gShowExcludedCutters = false,
  163.             DSeqPrintPrefs::gShowNoncutters = false;
  164. short    
  165.             DSeqPrintPrefs::gBasesPerLine = 60,
  166.             DSeqPrintPrefs::gREMinCuts = 1, 
  167.             DSeqPrintPrefs::gREMaxCuts = 999;
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174. // add this to ?? dgg.c
  175. inline void RectRgn(Nlm_RegioN rgn, Nlm_RectPtr r)
  176. {
  177.     Nlm_LoadRectRgn( rgn, r->left, r->top, r->right, r->bottom);
  178. }
  179.  
  180. inline short BaseCharWidth()
  181. {
  182.     return Nlm_CharWidth('G');
  183.     //return Nlm_MaxCharWidth(); 
  184.     //return Nlm_stdCharWidth;
  185. }
  186.  
  187.  
  188. class DDrawMapRow : public DObject {
  189. public:
  190.     enum { kNoIndex = -999, kMaxLinebuf= 1024 };
  191.     static char fLinebuf[kMaxLinebuf+1];
  192.     Nlm_FonT    fFont; 
  193.     char    * fName;
  194.     short      fHeight, fRowOffset, fLinecount, fItemrow;
  195.  
  196.     DDrawMapRow() : 
  197.         fFont(NULL), fName(NULL), fHeight(Nlm_stdLineHeight), 
  198.         fRowOffset(-1), fLinecount(0), fItemrow(0) 
  199.         {}
  200.     virtual void Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem) {}
  201.     virtual const char* Write( short row, short col, long startitem, long stopitem) { return ""; }
  202.     virtual char* GetName(short row) { return fName; }
  203.     virtual short GetIndex(short item) { return item; }
  204.     virtual short GetHeight( Nlm_RecT& r, short row, long startitem, long stopitem) { return fHeight; }
  205.     virtual Boolean DoLeftName() { return false; }
  206.     virtual void  Clip( Nlm_RecT& r, short row, long startitem, long stopitem,
  207.                                          Nlm_RecT& viewr, Nlm_RegioN cliprgn)
  208.     {
  209.         Nlm_ClipRgn( cliprgn);
  210.     }
  211. };
  212.  
  213. char DDrawMapRow::fLinebuf[DDrawMapRow::kMaxLinebuf+1];
  214.  
  215.  
  216. class DDrawSpacer : public DDrawMapRow {
  217. public:
  218.     char *fTitle;
  219.     DDrawSpacer( char* title= NULL, Nlm_FonT itsFont = NULL) : fTitle(title) { fFont= itsFont; }
  220.     virtual void Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem);
  221.     virtual const char* Write( short row, short col, long startitem, long stopitem);
  222.     virtual short GetIndex(short item) { return kNoIndex; }
  223. };
  224.  
  225. void DDrawSpacer::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  226. {
  227.     if (fTitle) {
  228.         if (fFont) Nlm_SelectFont(fFont);
  229.         Nlm_MoveTo( r.left, r.bottom-2);
  230.         Nlm_PaintString(fTitle);
  231.         }
  232. }
  233.  
  234. const char* DDrawSpacer::Write( short row, short col, long startitem, long stopitem)
  235. { 
  236.     long  len= Min( kMaxLinebuf, stopitem-startitem);
  237.     Nlm_MemFill(fLinebuf, ' ', len);
  238.     if (fTitle) MemCpy( fLinebuf, fTitle, Min( len, StrLen(fTitle)) );
  239.     fLinebuf[len]= 0;
  240.     return fLinebuf;
  241. }
  242.  
  243.  
  244.  
  245.  
  246. class DDrawIndexRow : public DDrawMapRow {
  247. public:
  248.     Nlm_Boolean fIsUp;
  249.     short    fItemWidth;
  250.     DDrawIndexRow( Nlm_FonT itsFont, short itemWidth, Nlm_Boolean upright= true) : 
  251.         fIsUp(upright),fItemWidth(itemWidth) 
  252.         { 
  253.             fFont= itsFont; 
  254.             if (fFont) Nlm_SelectFont(fFont);
  255.             fHeight= 3 + Nlm_LineHeight();
  256.         }
  257.     virtual void Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem);
  258.     virtual const char* Write( short row, short col, long startitem, long stopitem);
  259.     virtual short GetIndex(short item) { return kNoIndex; }
  260. };
  261.  
  262. void DDrawIndexRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  263. {  
  264.     short atx, aty, cleft, rowtop;
  265.     short up1, up2, upFont;
  266.     
  267.     if (col>0) startitem += col;
  268.  
  269.     if (fFont) Nlm_SelectFont(fFont);
  270.     cleft= r.left; // add a bit to move over bases
  271.     if (fIsUp) {
  272.         up1= -1;
  273.         up2= -3;
  274.         upFont= -4;
  275.         rowtop= r.bottom - kIndexRise; 
  276.         }
  277.     else {
  278.         up1= 1;
  279.         up2= 3;
  280.         upFont= Nlm_FontHeight();
  281.         rowtop= r.top + kIndexRise;
  282.         }
  283.     Nlm_MoveTo( cleft, rowtop);
  284.     Nlm_LineTo( r.right, rowtop);
  285.     
  286.     cleft += fItemWidth / 2; // add a bit to put tics over bases
  287.     for (long at= startitem; at <= stopitem; at++, cleft += fItemWidth) {
  288.         atx= cleft;
  289.         aty= rowtop;
  290.         Nlm_MoveTo( atx, aty);
  291.         if (at % 10 == 4) {
  292.             char  nums[128];
  293.             sprintf(nums, "%d", at+1);  
  294.             short ws= Nlm_StringWidth(nums);
  295.             aty += up1;
  296.             Nlm_LineTo(atx, aty);
  297.             aty += upFont;
  298.             atx -= ws/2;
  299.             Nlm_MoveTo( atx, aty);
  300.             Nlm_PaintString(nums);
  301.             }        
  302.         else {
  303.           aty += up2;
  304.             Nlm_LineTo(atx, aty);
  305.             }
  306.         }
  307. }
  308.     
  309. const char*  DDrawIndexRow::Write( short row, short col, long startitem, long stopitem)
  310. { 
  311.     long len, i, at;
  312.     char    * numline, * ticline, *cp;
  313.     
  314.     len= Min( kMaxLinebuf / 2, stopitem-startitem);
  315.     Nlm_MemFill( fLinebuf, ' ', (len + 1)*2);
  316.     if (fIsUp) {
  317.       numline= fLinebuf;
  318.         ticline= fLinebuf + len + 1;
  319.         }
  320.     else {
  321.       ticline= fLinebuf;
  322.         numline= fLinebuf + len + 1;
  323.         }
  324.     
  325.     for (i= 0, at=startitem; i < len; i++, at++) {
  326.         if (at % 10 == 4) {
  327.             char nums[128];
  328.             short  ws;
  329.             ticline[i]= '+';
  330.           sprintf(nums, "%d", at+1);
  331.           ws= StrLen(nums);
  332.           cp= numline + i - ws / 2;
  333.           MemCpy( cp, nums, ws);
  334.             }
  335.         //else if (fIsUp) ticline[i]= '_'; 
  336.         else 
  337.             ticline[i]= '-';
  338.         }
  339.  
  340.         fLinebuf[len]= '\n'; // newline !?
  341.         len= 2*len + 1;
  342.         fLinebuf[len]= 0;
  343.         return fLinebuf;
  344. }
  345.     
  346.     
  347.  
  348. class DDrawSeqRow : public DDrawMapRow {
  349. public:
  350.     DSeqPrintView * fView;
  351.     ulong    * fColors;
  352.     DSequence * fSeq, * fTopSeq, * fBotSeq;
  353.     char    * fBases;
  354.     char    * fFirstcommon, * fCommonbase;
  355.     long         fLength;
  356.     short        fItemWidth;
  357.     DList *    fStyles;
  358.     
  359.     DDrawSeqRow(Nlm_FonT itsFont, DSeqPrintView* itsView, DSequence* itsSeq,
  360.                                  DList* itsStyles, char* name, ulong* colors);
  361.     virtual void Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem);    
  362.     virtual const char* Write( short row, short col, long startitem, long stopitem);
  363.     virtual DSeqStyle* GetStyle(long ibase, short masklevel, DSequence* aSeq);
  364. };
  365.  
  366.  
  367. DDrawSeqRow::DDrawSeqRow(Nlm_FonT itsFont, DSeqPrintView* itsView, DSequence* itsSeq,
  368.                                                      DList* itsStyles, char* name, ulong* colors) : 
  369.         fView(itsView), fColors(colors), 
  370.         fSeq(itsSeq), fTopSeq(NULL), fBotSeq(NULL),
  371.         fStyles( itsStyles), 
  372.         fFirstcommon(NULL), fCommonbase(NULL),
  373.         fBases(NULL), fLength(0)
  374. {  
  375.     if (fSeq) {
  376.         fBases= fSeq->Bases();
  377.         fLength= fSeq->LengthF();
  378.         }
  379.     fFont= itsFont; 
  380.     fName= name; 
  381.     if (fFont) Nlm_SelectFont(fFont);
  382.     fHeight= Nlm_LineHeight();
  383.     fItemWidth= BaseCharWidth();
  384. }
  385.  
  386.  
  387.  
  388. DSeqStyle* DDrawSeqRow::GetStyle(long ibase, short masklevel, DSequence* aSeq)
  389. {
  390.     short maskval= 0;
  391.     if (aSeq) maskval= aSeq->MaskAt(ibase, masklevel);
  392.     if (maskval>0)  
  393.         return (DSeqStyle*) fStyles->At(masklevel-1);
  394.     else
  395.         return NULL;
  396. }
  397.  
  398.  
  399. void DDrawSeqRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  400. {
  401.     enum patvals { kNoPat, kHasFillPat, kHasFramePat };
  402.     char* bases= fBases;
  403.     if (bases && startitem < fLength) {
  404.     char    ch, lastch, *b;
  405.     short    atx, aty, masklevel, maskval;
  406.     long    ibase;
  407.     ulong    newcolor, curcolor, blackcolor;
  408.     patvals  haspat= kNoPat;
  409.          DSeqStyle * style, * laststyle, * nextstyle, * topstyle, * botstyle;
  410.    
  411.         if (col>0) {
  412.             bases += col; 
  413.             startitem += col;
  414.             }
  415.         if (stopitem > fLength) stopitem= fLength;
  416.         long len= stopitem - startitem;
  417.         atx= r.left;
  418.         aty= r.bottom - 2;
  419.         
  420.         if (fFont) Nlm_SelectFont(fFont);
  421.         Nlm_Black();
  422.         Nlm_TextTransparent();
  423.         curcolor= blackcolor= Nlm_GetColor();
  424.         
  425. #if MASKS
  426.         topstyle= botstyle= NULL;
  427.         laststyle= nextstyle= NULL;
  428.         if (startitem>0) 
  429.          for (masklevel=1; masklevel<5; masklevel++) {
  430.             laststyle= GetStyle( startitem-1, masklevel, fSeq);
  431.             if (laststyle) break;
  432.             }
  433. #endif
  434.             
  435.         lastch= 0;
  436.         for (b= bases + startitem, ibase=startitem; *b && ibase<stopitem; b++, ibase++) {
  437.             Nlm_MoveTo( atx, aty);
  438.             ch= *b;
  439.             if (ch == DSequence::indelSoft) ch= DSequence::indelHard; //looks better for output...
  440.     
  441. #if MASKS
  442.             Boolean needdraw= true;
  443.             Nlm_RecT crec;
  444.             maskval= fSeq->MaskAt(ibase,0); // val for all masks
  445.             if (maskval>0) 
  446.              for (masklevel=1; needdraw && masklevel<5; masklevel++) {
  447.                     // LATER: want to allow drawing of all mask forms for each base !?
  448.                 style= GetStyle( ibase, masklevel, fSeq);
  449.                 if (style) {
  450.                     Nlm_LoadRect( &crec, atx, r.top, atx+fItemWidth, r.bottom);
  451.                     nextstyle= GetStyle( ibase+1, masklevel, fSeq);
  452.                     topstyle= GetStyle( ibase, masklevel, fTopSeq);
  453.                     botstyle= GetStyle( ibase, masklevel, fBotSeq);
  454.  
  455. #if 1
  456.                     if (style->repeatchar && fItemrow > 0 
  457.                         && fCommonbase && fFirstcommon
  458.                         && fCommonbase[ibase] != '!'
  459.                         && fItemrow > (unsigned char)fFirstcommon[ibase]
  460.                         && toupper(ch) == fCommonbase[ibase]) 
  461.                           ch= style->repeatchar;
  462. #else                    
  463.                     if (style->repeatchar && fItemrow > 0 
  464.                         && DStyleTable::fToprow 
  465.                         && ibase < DStyleTable::fToprowlen 
  466.                         && ch == DStyleTable::fToprow[ibase]) 
  467.                           ch= style->repeatchar;
  468. #endif
  469.                           
  470.                     if (style->uppercase) ch= toupper(ch);
  471.                     else if (style->lowercase) ch= tolower(ch);
  472.                     
  473.                     if (style->font && 
  474.                     (style->font != Nlm_fontInUse || style->font != DStyleTable::fLaststyle.font)) 
  475.                           Nlm_SelectFont(style->font);
  476.                          
  477.                         // this is good only w/ backcolor !?
  478.                      if (style->dofontpat) { 
  479.                         if ( haspat == kHasFillPat || 
  480.                          (Nlm_MemCmp(style->fontpattern, DStyleTable::fLaststyle.fontpattern, 8) != 0)
  481.                          ) {
  482.                              Nlm_PenPattern(style->fontpattern);  
  483.                              haspat= kHasFillPat;
  484.                              }
  485.                          }
  486.                      else if (haspat) { Nlm_Solid(); haspat= kNoPat; }
  487.                              
  488.                     if (style->dobackcolor) { 
  489.                         newcolor= style->backcolor;
  490.                         if (curcolor != newcolor) {
  491.                             curcolor= newcolor;
  492.                             Nlm_SetColor( curcolor);  
  493.                             }
  494.                         Nlm_PaintRect(&crec);
  495.                         }  
  496.  
  497.                     if (style->dofontcolor) newcolor= style->fontcolor;
  498.                     else if (fColors) newcolor= fColors[ch-' '];
  499.                     else newcolor= blackcolor;  
  500.                     if (curcolor != newcolor) {
  501.                         curcolor= newcolor;
  502.                         Nlm_SetColor( curcolor);  
  503.                         }
  504.  
  505.                     //if (style->invertcolor) Nlm_InvertColors();
  506.                     //if (style->invertcolor) Nlm_EraseMode();//TextMode(srcBIC);
  507.                     
  508.                     Nlm_PaintChar(ch);
  509.                     needdraw= false;
  510.  
  511.                     //if (style->invertcolor) Nlm_CopyMode();
  512.                     if (style->invertcolor) Nlm_InvertRect( &crec);
  513.                     
  514.                     if (style->frame) { 
  515.                         Boolean anyframe, leftframe, rightframe, topframe, botframe;
  516.                         leftframe = (!(laststyle && laststyle->frame));
  517.                         rightframe= (!(nextstyle && nextstyle->frame));
  518.                         topframe  = (!(topstyle && topstyle->frame));
  519.                         botframe  = (!(botstyle && botstyle->frame));
  520.                         anyframe  = leftframe||rightframe||topframe||botframe;
  521.                         
  522.                         if (anyframe) { 
  523.                           if (style->doframecolor) newcolor= style->framecolor;
  524.                             else newcolor= blackcolor; 
  525.                             if (curcolor != newcolor) {
  526.                                 curcolor= newcolor;
  527.                                 Nlm_SetColor( curcolor);  
  528.                                 }
  529.                              if (style->framestyle) { 
  530.                                  switch (style->framestyle) {
  531.                                      case DSeqStyle::kFrameSolid : Nlm_Solid(); break;
  532.                                      case DSeqStyle::kFrameDark  : Nlm_Dark(); break;
  533.                                      case DSeqStyle::kFrameMedium: Nlm_Medium(); break;
  534.                                      case DSeqStyle::kFrameLight : Nlm_Light(); break;
  535.                                      case DSeqStyle::kFrameDotted: Nlm_Dotted(); break;
  536.                                      case DSeqStyle::kFrameDashed: Nlm_Dashed(); break;
  537.                                      }
  538.                                  }
  539.                              haspat= kHasFramePat;
  540.                             }
  541.  
  542.                         if (leftframe) { 
  543.                             Nlm_MoveTo(crec.left,crec.top); 
  544.                             Nlm_LineTo(crec.left,crec.bottom); 
  545.                             } 
  546.                         if (rightframe) { 
  547.                             Nlm_MoveTo(crec.right-1,crec.top); 
  548.                             Nlm_LineTo(crec.right-1,crec.bottom); 
  549.                             } 
  550.                         if (topframe) { 
  551.                             Nlm_MoveTo(crec.left,crec.top); 
  552.                             Nlm_LineTo(crec.right,crec.top); 
  553.                             } 
  554.                         if (botframe) { 
  555.                             Nlm_MoveTo(crec.left,crec.bottom-1); 
  556.                             Nlm_LineTo(crec.right,crec.bottom-1); 
  557.                             } 
  558.                         if (anyframe) Nlm_TextTransparent(); // MSWin LineTo/DrawLine resets Opaque!
  559.                         }
  560.  
  561.                     DStyleTable::fLaststyle= *style;
  562.                     laststyle= style;
  563.                     }
  564.                 }
  565.             
  566.             if (needdraw) {
  567.                 if (haspat) { Nlm_Solid(); haspat= kNoPat; }
  568.                  if (Nlm_fontInUse != fFont) Nlm_SelectFont(fFont); 
  569.                 if (fColors) {
  570.                     newcolor= fColors[ch-' '];
  571.                     if (curcolor != newcolor) {
  572.                         curcolor= newcolor;
  573.                         Nlm_SetColor( curcolor);  
  574.                         }
  575.                     }
  576.                 else if (curcolor != blackcolor) {
  577.                     Nlm_Black(); // if WithStyle left a color set.... !!
  578.                     curcolor= blackcolor;
  579.                     }
  580.                 Nlm_PaintChar(ch);
  581.                 laststyle= NULL;
  582.                 }
  583.  
  584. #else
  585.              if (fColors) {
  586.                  // if (swapBackcolor) Nlm_SetBackColor( fColors[ch-' ']); else 
  587.                 if (ch!=lastch) Nlm_SetColor( fColors[ch-' ']);
  588.                 }
  589.             Nlm_PaintChar(ch);
  590. #endif
  591.             lastch= ch;
  592.             atx += fItemWidth;   
  593.             }    
  594.         Nlm_TextOpaque();
  595.         Nlm_Black();
  596.         if (haspat) { Nlm_Solid(); haspat= kNoPat; }
  597.         curcolor= blackcolor;
  598.         }
  599. }
  600.  
  601. const char* DDrawSeqRow::Write( short row, short col, long startitem, long stopitem)
  602. { 
  603.     long  len, i;
  604.     char* bases= fBases;
  605.     len= Min( kMaxLinebuf, stopitem-startitem);
  606.     if (bases && startitem < fLength) {
  607.     char    ch, *b;
  608.         if (stopitem > fLength) stopitem= fLength;        
  609.         for (b= bases + startitem, i=0; *b && i<len; b++, i++) {
  610.             ch= *b;
  611.             if (ch == DSequence::indelSoft) ch= DSequence::indelHard; //looks better
  612.             fLinebuf[i]= ch;
  613.             }    
  614.         for ( ; i<len; i++) fLinebuf[i]= ' ';
  615.         }
  616.     fLinebuf[len]= 0;
  617.     return fLinebuf;
  618. }
  619.     
  620.     
  621.  
  622. class DDrawManySeqRow : public DDrawSeqRow {
  623. public:
  624.     DSeqList * fSeqList;
  625.     //short             fLinesPerparag, fTopPerparag;
  626.     
  627.     DDrawManySeqRow(Nlm_FonT itsFont, DSeqPrintView* itsView, 
  628.                                     DSeqList* seqlist, long seqIndex, DList* itsStyles, ulong* colors,
  629.                                     char* commonbases, char* firstcommon);
  630. #if 0
  631.     virtual ~DDrawManySeqRow();
  632.     virtual void Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem);    
  633.     virtual const char* Write( short row, short col, long startitem, long stopitem);
  634.     virtual char* GetName(short row);
  635. #endif
  636. };
  637.  
  638.  
  639. DDrawManySeqRow::DDrawManySeqRow(Nlm_FonT itsFont, DSeqPrintView* itsView, 
  640.                                             DSeqList* seqlist, long seqIndex, DList* itsStyles, ulong* colors,
  641.                                             char* commonbases, char* firstcommon) : 
  642.       DDrawSeqRow( itsFont, itsView, NULL, itsStyles, NULL, colors),
  643.         fSeqList(seqlist)
  644. {
  645.     fItemrow= seqIndex;
  646.     fSeq= seqlist->SeqAt( fItemrow);
  647.     if (fSeq) {
  648.         fName= fSeq->Name();
  649.         fBases= fSeq->Bases();
  650.         fLength= fSeq->LengthF();
  651.         }
  652.     fTopSeq= seqlist->SeqAt(fItemrow-1);
  653.     fBotSeq= seqlist->SeqAt(fItemrow+1);
  654.     fCommonbase= commonbases;
  655.     fFirstcommon= firstcommon;
  656.     //fCommonbase= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, fFirstcommon);
  657. }
  658.  
  659. #if 0
  660. DDrawManySeqRow::~DDrawManySeqRow()
  661. {
  662. }
  663.  
  664. char* DDrawManySeqRow::GetName(short row)
  665. {
  666.     //DSequence* aSeq= NULL;
  667.     //short atseq= (row % fLinesPerparag) - fTopPerparag;
  668.     //if (fItemrow>=0) aSeq= (DSequence*) fSeqList->At( fItemrow);
  669.     //if (fSeq) return fSeq->Name(); else 
  670.     return fName;
  671. }
  672.  
  673. void DDrawManySeqRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  674. {
  675.     //DSequence* aSeq= NULL;
  676. //    short atseq= (row % fLinesPerparag) - fTopPerparag; // == fItemrow
  677.     //if (fItemrow>=0) aSeq= (DSequence*) fSeqList->At(fItemrow);
  678.     if (fSeq) {
  679.         //fSeq= aSeq;
  680.         //fTopSeq= (DSequence*) fSeqList->At(fItemrow-1);
  681.         //fBotSeq= (DSequence*) fSeqList->At(fItemrow+1);
  682.         //fBases= aSeq->Bases();
  683.         //fLength= aSeq->LengthF();
  684.       DDrawSeqRow::Draw( r, row, col, startitem, stopitem);
  685.         }
  686. }
  687.  
  688. const char* DDrawManySeqRow::Write( short row, short col, long startitem, long stopitem)
  689. { 
  690.     //DSequence* aSeq= NULL;
  691. //    short atseq= (row % fLinesPerparag) - fTopPerparag;
  692.     //if (fItemrow>=0) aSeq= (DSequence*) fSeqList->At(fItemrow);
  693.     if (fSeq) {
  694.         //fSeq= aSeq;
  695.         //fBases= aSeq->Bases();
  696.         //fLength= aSeq->LengthF();
  697.       return DDrawSeqRow::Write( row, col, startitem, stopitem);
  698.         }
  699.     else
  700.         return "";
  701. }
  702.  
  703. #endif
  704.  
  705.  
  706.  
  707. class DDrawAminoRow : public DDrawMapRow {
  708. public:
  709.     char        fNameStore[20];
  710.     char        * fBases;
  711.     short        fFrame, fItemWidth;
  712.     Boolean fThreeLet, fOnlyORF;
  713.     DSequence * fAAseq;
  714.     long        fLength;
  715.     
  716.     DDrawAminoRow(Nlm_FonT itsFont, DSequence* itsSeq, short frame);
  717.     virtual ~DDrawAminoRow() { if (fAAseq) delete fAAseq; }
  718.     virtual void Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem);    
  719.     virtual const char* Write( short row, short col, long startitem, long stopitem);
  720.     virtual short GetIndex(short item) { return kNoIndex; }
  721. };
  722.  
  723.  
  724. DDrawAminoRow::DDrawAminoRow(Nlm_FonT itsFont, DSequence* itsSeq, short frame) : 
  725.         fAAseq(NULL), fFrame( frame), fLength(0), 
  726.         fOnlyORF(DSeqPrintPrefs::gOnlyORF),
  727.         fThreeLet(DSeqPrintPrefs::gThreeLetAA) 
  728. {
  729.     Boolean iscomp = frame > 2;
  730.     short   offset = frame % 3;
  731.     fFont= itsFont;
  732.     if (fFont) Nlm_SelectFont(fFont);
  733.     fHeight= Nlm_LineHeight();
  734.     fItemWidth= BaseCharWidth();
  735.     sprintf( fNameStore, "aa%d", frame);
  736.     fName= fNameStore;
  737.     if (iscomp) {
  738.         itsSeq->SetSelection( -1,-1);
  739.         itsSeq= itsSeq->Reverse();
  740.             // strange patches...
  741.         if (offset==1) offset= 2;     
  742.         else if (offset==2) offset= 1; 
  743.         if (offset==2) itsSeq->InsertSpacers(itsSeq->LengthF(),offset,'?');   
  744.         }
  745.     itsSeq->SetSelection( offset, itsSeq->LengthF() - offset);
  746.     fAAseq= itsSeq->Translate(false);
  747.     if (iscomp) { delete itsSeq; itsSeq= NULL; }
  748.     if (fAAseq) {
  749.         fBases= fAAseq->Bases();
  750.         fLength= fAAseq->LengthF();
  751.         if (fOnlyORF) {
  752.             long    i;
  753.             Boolean isorf;
  754.             char startamino= DCodons::startamino();
  755.             for (isorf= true, i= 0; i<fLength; i++) {
  756.                 if (isorf) {
  757.                   if (fBases[i] == '*') isorf= false;
  758.                   }
  759.                 else {
  760.                      if (fBases[i] == startamino) isorf= true;
  761.                      if (!isorf) fBases[i]= ' ';
  762.                     }
  763.                 }
  764.             }
  765.         if (iscomp) { 
  766.             fAAseq->SetSelection( -1,-1);
  767.             DSequence* unrevAA= fAAseq->Reverse(); 
  768.             delete fAAseq; 
  769.             fAAseq= unrevAA; 
  770.             fBases= fAAseq->Bases();
  771.             fLength= fAAseq->LengthF();
  772.             }
  773.         }
  774. }
  775.  
  776. void DDrawAminoRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  777. {
  778.     long   len;
  779.     short  leftindent;
  780.     char*  bases= fBases;
  781.     if (bases) {
  782.         if (col) {
  783.             bases += col; 
  784.             startitem += col;
  785.             }
  786. #if 0
  787.       short indents[3,3] = {
  788.                           {0,1,2},
  789.                                                 {2,0,1},
  790.                                               {1,2,0}
  791.                                                 };
  792.         // at   0 -> 0,1,2 now & want          0%3=0
  793.         // at  50 -> 2,0,1 now -> 1,2,0 want  50%3=2
  794.         // at 100 -> 1,2,0 now -> 2,0,1 want 100%3=1
  795.         // at 150 -> 0,1,2 now & want        150%3=0
  796. #endif
  797.         leftindent=  (fFrame + (3 - (startitem % 3)) % 3) % 3; 
  798.         
  799.         len= (stopitem - startitem + 2) / 3;
  800.         startitem = (startitem + 2) / 3;  // adjust for 3-to-1 NA-to-AA translate
  801.         if (startitem + len > fLength) len= fLength - startitem;
  802.         if (startitem < fLength) {
  803.         char     *b;
  804.         short  chleft, chvert, chwidth;
  805.             
  806.             chvert= r.bottom-2;
  807.             chwidth = fItemWidth; 
  808.             chleft = r.left + chwidth * leftindent;    
  809.             chwidth *= 3;    
  810.             if (fFont) Nlm_SelectFont(fFont);
  811.             if (fThreeLet) for (b= bases+startitem; *b && len; b++, len--) {
  812.                 Nlm_MoveTo( chleft, chvert);
  813.                 Nlm_PaintString( (char*) DSequence::Amino123(*b));
  814.                 chleft += chwidth;
  815.                 }
  816.             else for (b= bases+startitem; *b && len; b++, len--) {
  817.                 Nlm_MoveTo( chleft, chvert);
  818.                 Nlm_PaintChar(*b);
  819.                 chleft += chwidth;
  820.                 }        
  821.             }
  822.         }
  823. }
  824.  
  825. const char* DDrawAminoRow::Write( short row, short col, long startitem, long stopitem)
  826. { 
  827.     long   len, alen;
  828.     short  leftindent;
  829.     char*  bases= fBases;
  830.     if (bases) {
  831.         len= Min( kMaxLinebuf, 1+stopitem-startitem);
  832.         Nlm_MemFill( fLinebuf, ' ', len);
  833.         
  834.         leftindent=  (fFrame + (3 - (startitem % 3)) % 3) % 3; 
  835.         
  836.         alen= (stopitem - startitem + 2) / 3;
  837.         startitem = (startitem + 2) / 3;  // adjust for 3-to-1 NA-to-AA translate
  838.         if (startitem + alen > fLength) alen= fLength - startitem;
  839.         if (startitem < fLength) {
  840.         char    *b, *cp;
  841.         long    i;
  842.             i= leftindent;    
  843.             if (fThreeLet) 
  844.              for (b= bases+startitem; *b && alen && i<len; b++, alen--, i += 3) {
  845.                 char * amino3= (char*) DSequence::Amino123(*b);
  846.                 cp= fLinebuf + i;
  847.                 MemCpy( cp, amino3, 3);
  848.                 }
  849.             else 
  850.              for (b= bases+startitem; *b && alen && i<len; b++, alen--, i += 3) {
  851.                 fLinebuf[i]= *b;
  852.                 }        
  853.             }
  854.         }
  855.     fLinebuf[len]= 0;
  856.     return fLinebuf;
  857. }
  858.     
  859.  
  860.  
  861. class DDrawZymeTable : public DDrawMapRow { 
  862. public:
  863.     char** fLinelist;
  864.     char * fTableTitle;
  865.     
  866.     DDrawZymeTable(Nlm_FonT itsFont, DREMap* itsREMap, short rowoffset);
  867.     virtual ~DDrawZymeTable();
  868.     virtual void Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem);    
  869.     virtual const char* Write( short row, short col, long startitem, long stopitem);
  870.     virtual short GetIndex(short item) { return kNoIndex; }
  871.     virtual char* TableLine(short atline); 
  872.     virtual void  Clip( Nlm_RecT& r, short row, long startitem, long stopitem,
  873.                                              Nlm_RecT& viewr, Nlm_RegioN cliprgn);
  874. };
  875.  
  876. class DDrawAllZymeTable : public DDrawZymeTable { 
  877. public:
  878.     DDrawAllZymeTable(Nlm_FonT itsFont, DREMap* itsREMap, short rowoffset);
  879. };
  880.  
  881. class DDrawNocutZymeTable : public DDrawZymeTable { 
  882. public:
  883.     DDrawNocutZymeTable(Nlm_FonT itsFont, DREMap* itsREMap, short rowoffset, 
  884.                                             short mincuts = 0, short maxcuts = 0);
  885. };
  886.  
  887.  
  888. DDrawZymeTable::DDrawZymeTable(Nlm_FonT itsFont, DREMap * itsREMap, short rowoffset) :
  889.         fLinelist(NULL)
  890. {
  891.   fName= "";
  892.     fFont= itsFont;
  893.     if (fFont) Nlm_SelectFont(fFont);
  894.     fHeight= Nlm_LineHeight(); 
  895.     fTableTitle= "TABLE of enzymes";
  896.     fRowOffset= rowoffset;
  897. }
  898.  
  899. DDrawZymeTable::~DDrawZymeTable() 
  900. { 
  901.     for (short i=0; i<fLinecount; i++) MemFree( fLinelist[i]);
  902.     MemFree( fLinelist); 
  903. }
  904.  
  905.  
  906. char* DDrawZymeTable::TableLine(short atline) 
  907. { 
  908.     //if (atline == 0) return fTableTitle; else 
  909.     if (atline>=0 && atline<fLinecount) return fLinelist[atline];  
  910.     else return "";
  911. }
  912.  
  913. void  DDrawZymeTable::Clip( Nlm_RecT& r, short row, long startitem, long stopitem,
  914.                                          Nlm_RecT& viewr, Nlm_RegioN cliprgn)
  915. {
  916.     //Nlm_ClipRgn( cliprgn);
  917.     Nlm_RecT clipr= r;
  918.     clipr.left= viewr.left + 10;
  919.     clipr.right= viewr.right - 10;
  920.     clipr.bottom= Min( r.bottom, viewr.bottom);
  921.     clipr.top= Max(r.top, viewr.top);
  922.     Nlm_ClipRect( &clipr);
  923. }
  924.  
  925. void DDrawZymeTable::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  926. {
  927.     short     chleft, chvert, atline;
  928.     char  * tabline;
  929.     
  930.     chleft = r.left;
  931.     chvert = r.bottom-2;
  932.     atline = row - fRowOffset;
  933.     tabline= TableLine(atline);
  934.     if (tabline) {
  935.         if (col) { 
  936.           if (StrLen(tabline)>col) tabline += col; // ??? offset TableLine by # cols ?
  937.             else tabline= "";
  938.             }
  939.         if (fFont) Nlm_SelectFont(fFont);
  940.       if (atline == 0) {
  941.             Nlm_MoveTo( chleft, chvert-1);
  942.              Nlm_PaintString( tabline);
  943.             Nlm_MoveTo( r.left, r.bottom-1);
  944.             Nlm_LineTo( r.right, r.bottom-1);
  945.           }
  946.         else if (atline >= 0 && atline < fLinecount) {
  947.             Nlm_MoveTo( chleft, chvert);
  948.             Nlm_PaintString( tabline);
  949.             }
  950.         }
  951. }
  952.  
  953. const char* DDrawZymeTable::Write( short row, short col, long startitem, long stopitem)
  954. { 
  955.     long   len, atline;
  956.     char   * cp;
  957.  
  958.     atline = row - fRowOffset;
  959.     len= Min( kMaxLinebuf, 80);
  960.   if (atline == 0) {
  961.         Nlm_MemFill( fLinebuf, '_', len);
  962.          StrCpy( fLinebuf, TableLine(atline));
  963.          cp= StrChr(fLinebuf, '\0');
  964.          if (cp) *cp= ' ';
  965.       }
  966.     else if (atline >= 0 && atline < fLinecount) {
  967.         Nlm_MemFill( fLinebuf, ' ', len);
  968.         cp = TableLine(atline);
  969.         StrCpy( fLinebuf, cp);
  970.          cp= StrChr(fLinebuf, '\0');
  971.          if (cp) *cp= ' ';
  972.         }
  973.     else {
  974.         Nlm_MemFill( fLinebuf, ' ', len);
  975.         }
  976.     fLinebuf[len]= 0;
  977.     return fLinebuf;
  978. }
  979.  
  980.  
  981.  
  982. DDrawAllZymeTable::DDrawAllZymeTable(Nlm_FonT itsFont, DREMap * itsREMap, short rowoffset) :
  983.         DDrawZymeTable( itsFont, itsREMap, rowoffset)
  984. { 
  985.     fTableTitle= "TABLE of all enzymes";
  986.     if (1) {
  987.         char  * zymeline = NULL;
  988.         long  i, nzymes, linelen, linecount;
  989.         char  buf[128], comma;
  990.  
  991.         nzymes= DREMap::fREnzymes->GetSize();
  992.         linecount= 4 + nzymes / 4;
  993.         fLinelist= (char**) MemNew( linecount * sizeof(char*)); 
  994.         fLinecount= 0;
  995.         sprintf( buf, "  TABLE of All Enzymes  (name: cut count)");
  996.         fLinelist[fLinecount++]= StrDup(buf);
  997.         //sprintf( buf, " ");
  998.         //fLinelist[fLinecount++]= StrDup(buf);
  999.     
  1000.         for (i=0, comma = ','; i<nzymes; i++) {
  1001.             if (i == nzymes-1) comma= ' ';
  1002.             DREnzyme* re= (DREnzyme*) DREMap::fREnzymes->At(i);
  1003.             if (re) {
  1004.                 //sprintf( buf, "%10s:%3d%c  ", re->fName, re->fCutcount, comma);
  1005.                 sprintf( buf, "%9s:%3d  ", re->fName, re->fCutcount, comma);
  1006.                 if (zymeline)  
  1007.                     zymeline= Dgg_StrExtendCat( &zymeline, buf);
  1008.                 else {
  1009.                     zymeline= StrDup(buf);
  1010.                     }
  1011.               linelen= StrLen(zymeline);
  1012.                 if (linelen > 70) {
  1013.                     fLinelist[fLinecount++]= zymeline;
  1014.                     zymeline= NULL;
  1015.                     }
  1016.                 }
  1017.  
  1018.           if (fLinecount >= linecount) {
  1019.               linecount += 10;
  1020.               fLinelist= (char**) Nlm_MemMore( fLinelist, linecount * sizeof(char*));
  1021.               }
  1022.             }
  1023.         if (zymeline) fLinelist[fLinecount++]= zymeline;
  1024.         }
  1025. }
  1026.  
  1027.  
  1028. DDrawNocutZymeTable::DDrawNocutZymeTable( Nlm_FonT itsFont, DREMap * itsREMap,
  1029.              short rowoffset, short mincuts, short maxcuts) :
  1030.         DDrawZymeTable( itsFont, itsREMap, rowoffset)
  1031. { 
  1032.     if (maxcuts) fTableTitle= "TABLE of excluded enzymes";
  1033.     else fTableTitle= "TABLE of non-cutting enzymes";
  1034.     if (1) {
  1035.         char  * zymeline = NULL;
  1036.         long  i, nzymes, linelen, linecount;
  1037.         char  buf[128], comma;
  1038.         Boolean dolist;
  1039.         
  1040.         nzymes= DREMap::fREnzymes->GetSize();
  1041.         linecount= 4 + nzymes / 6;
  1042.         fLinelist= (char**) MemNew( linecount * sizeof(char*)); 
  1043.         fLinecount= 0;
  1044.         if (maxcuts) sprintf( buf, "  TABLE of Excluded Enzymes");
  1045.         else sprintf( buf, "  TABLE of Noncutting Enzymes");
  1046.         fLinelist[fLinecount++]= StrDup(buf);
  1047.         if (maxcuts) {
  1048.             sprintf( buf, "  (cut with less than %d or more than %d cuts)", mincuts, maxcuts);
  1049.             fLinelist[fLinecount++]= StrDup(buf);
  1050.             }
  1051.             
  1052.         for (i=0, comma = ','; i<nzymes; i++) {
  1053.             //if (i == nzymes-1) comma= ' ';
  1054.             DREnzyme* re= (DREnzyme*) DREMap::fREnzymes->At(i);
  1055.             if (re) {
  1056.                 if (maxcuts)  
  1057.                     dolist= (re->fCutcount > 0 && (re->fCutcount < mincuts || re->fCutcount > maxcuts));  
  1058.                 else 
  1059.                     dolist= re->fCutcount == 0;
  1060.                 if (dolist) {
  1061.                     //sprintf( buf, "%9s%c ", re->fName,comma);
  1062.                     sprintf( buf, "%9s ", re->fName);
  1063.                     if (zymeline)  
  1064.                         zymeline= Dgg_StrExtendCat( &zymeline, buf);
  1065.                     else {
  1066.                         zymeline= StrDup(buf);
  1067.                         }
  1068.                   linelen= StrLen(zymeline);
  1069.                     if (linelen > 60) {
  1070.                         fLinelist[fLinecount++]= zymeline;
  1071.                         zymeline= NULL;
  1072.                         }
  1073.                     }
  1074.                 }
  1075.  
  1076.           if (fLinecount >= linecount) {
  1077.               linecount += 10;
  1078.               fLinelist= (char**) Nlm_MemMore( fLinelist, linecount * sizeof(char*));
  1079.               }
  1080.             }
  1081.         if (zymeline) fLinelist[fLinecount++]= zymeline;
  1082.         }
  1083. }
  1084.  
  1085.  
  1086.  
  1087.  
  1088.  
  1089.  
  1090.  
  1091.  
  1092. class DDrawZymeCutTable : public DDrawZymeTable { 
  1093. public:
  1094.     DRECutsItem * fCutList;               
  1095.     long    fCutcount;
  1096.     short    fCuttersCount;             //# zymes that cut
  1097.     
  1098.     DDrawZymeCutTable(Nlm_FonT itsFont, DREMap* itsREMap, short rowoffset);
  1099.     virtual ~DDrawZymeCutTable();
  1100.     virtual char* TableLine(short atline); 
  1101.     virtual char* GetName(short row); 
  1102.     virtual Boolean DoLeftName() { return true; }
  1103. };
  1104.  
  1105.  
  1106. #ifdef WIN_MSWIN
  1107. static int LIBCALLBACK
  1108. #else
  1109. static int
  1110. #endif
  1111. zymenameCompare(void* a, void* b)
  1112. {
  1113.     short diff = StringCmp(((DRECutsItem*)a)->fREnzyme->fName, ((DRECutsItem*)b)->fREnzyme->fName);
  1114.     if (diff == 0) {
  1115.         return ((DRECutsItem*)a)->fSeqIndex - ((DRECutsItem*)b)->fSeqIndex;
  1116.         }
  1117.     else 
  1118.         return diff;
  1119. }
  1120.  
  1121.  
  1122.  
  1123. DDrawZymeCutTable::DDrawZymeCutTable(Nlm_FonT itsFont, DREMap * itsREMap, short rowoffset) :
  1124.         DDrawZymeTable( itsFont, itsREMap, rowoffset),
  1125.         fCutList(NULL), fCutcount(0), fCuttersCount(0)
  1126. { 
  1127.     fTableTitle= "TABLE of cut points";
  1128.     if (itsREMap) {
  1129.         fCutcount= itsREMap->fCutcount;
  1130.         fCuttersCount= itsREMap->fCuttersCount;
  1131.         fCutList= (DRECutsItem*) Nlm_MemDup( itsREMap->fSeqCuts, fCutcount * sizeof(DRECutsItem));
  1132.         if (fCutList) {
  1133.             long  i, at, lastat, linecount, linelen;
  1134.             char  *name, *zymeline = NULL, *lastname="";
  1135.             char  buf[128];
  1136.             
  1137.             Nlm_HeapSort( fCutList, fCutcount, sizeof(DRECutsItem), zymenameCompare);
  1138.             
  1139.             // what if we need more than one line for zyme cut list !!
  1140.             for (i=0, linecount= 0; i<fCutcount; i++) {
  1141.                 name= fCutList[i].fREnzyme->fName;
  1142.                 if (StringCmp(name, lastname)!=0) linecount++;
  1143.                 lastname= name;
  1144.                 }
  1145.           linecount += 3;
  1146.             fLinelist= (char**) MemNew( linecount * sizeof(char*)); 
  1147.             
  1148.             fLinecount= 0;
  1149.             sprintf( buf, "  TABLE of Cut Points");
  1150.             fLinelist[fLinecount++]= StrDup(buf);
  1151.             //sprintf( buf, " ");
  1152.             //fLinelist[fLinecount++]= StrDup(buf);
  1153.  
  1154.           linelen= 0;
  1155.             lastname= ""; lastat= -1;
  1156.             for (i=0; i<fCutcount && fLinecount < linecount; i++) {
  1157.                 name= fCutList[i].fREnzyme->fName;
  1158.                 at= fCutList[i].fSeqIndex;
  1159.                 if (StringCmp(name, lastname)==0 && linelen<70) { 
  1160.                     if (at != lastat) {
  1161.                       sprintf(buf, " %d", at);
  1162.                         if (zymeline) { 
  1163.                           zymeline= Dgg_StrExtendCat( &zymeline, buf);
  1164.                           linelen= StrLen(zymeline);
  1165.                           }
  1166.                       }
  1167.                     }
  1168.                 else {
  1169.                     if (zymeline) fLinelist[fLinecount++]= zymeline;
  1170.                     sprintf(buf, "%s: %d", name, at);
  1171.                     zymeline= (char*) MemNew(StrLen(buf)+1);
  1172.                     Nlm_StringCpy(zymeline, buf);
  1173.                     linelen= StrLen(buf);
  1174.                     }
  1175.                     
  1176.                 lastname= name;
  1177.                 lastat= at;
  1178.               if (fLinecount >= linecount) {
  1179.                   linecount += 10;
  1180.                   fLinelist= (char**) Nlm_MemMore( fLinelist, linecount * sizeof(char*));
  1181.                   }
  1182.                 }
  1183.             if (zymeline) fLinelist[fLinecount++]= zymeline;
  1184.             }
  1185.         }
  1186. }
  1187.  
  1188.  
  1189. DDrawZymeCutTable::~DDrawZymeCutTable() 
  1190. { 
  1191.     MemFree( fCutList); 
  1192. }
  1193.  
  1194. char* DDrawZymeCutTable::TableLine(short atline) 
  1195. { 
  1196.     //if (atline == 0) return fTableTitle; else 
  1197.     if (atline>=0 && atline<fLinecount) {
  1198.         char * name = fLinelist[atline];
  1199.         char * cp= StrChr(name,':'); 
  1200.         if (cp) cp++; else cp= name;
  1201.         return cp;  
  1202.         }
  1203.     else return "";
  1204. }
  1205.  
  1206. char* DDrawZymeCutTable::GetName(short row) 
  1207. { 
  1208.     enum { kNameLen = 80 };
  1209.     static char name[kNameLen];
  1210.     short atline = row - fRowOffset;
  1211.   if (atline == 0) {
  1212.         return "ENZYME";
  1213.         }
  1214.     else if (atline> 0 && atline < fLinecount) {
  1215.         StrNCpy(name, fLinelist[atline], kNameLen-1);
  1216.         name[kNameLen-1]= 0;
  1217.         char* cp= StrChr(name,':'); if (cp) *cp= 0;
  1218.         return name;
  1219.         }
  1220.     else
  1221.         return fName; 
  1222. }
  1223.  
  1224.  
  1225.  
  1226. class DDrawZymeRow : public DDrawMapRow { 
  1227. public:
  1228.   DSequence * fSeq, * fCoSeq;
  1229.     DREMap * fREMap;
  1230.     short        fMinCuts, fMaxCuts;
  1231.     DRECutsItem * fCutList;
  1232.     Boolean     fGoodMap;
  1233.     
  1234.     DDrawZymeRow( Nlm_FonT itsFont, DSequence* itsSeq);
  1235.     virtual ~DDrawZymeRow() { delete fREMap; }
  1236.     virtual short DrawOrMeasure( Nlm_Boolean doDraw, Nlm_RecT& r, short row, long startitem, long stopitem);    
  1237.     virtual void  Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem);    
  1238.     virtual const char* Write( short row, short col, long startitem, long stopitem);
  1239.     virtual short GetIndex(short item) { return kNoIndex; }
  1240.     virtual short GetHeight( Nlm_RecT& r, short row, long startitem, long stopitem); 
  1241.     virtual void  Clip( Nlm_RecT& r, short row, long startitem, long stopitem,
  1242.                                              Nlm_RecT& viewr, Nlm_RegioN cliprgn);
  1243. };
  1244.  
  1245.  
  1246. DDrawZymeRow::DDrawZymeRow(Nlm_FonT itsFont, DSequence* itsSeq) : 
  1247.       fSeq( itsSeq), fGoodMap(false), fCoSeq(NULL), fCutList(NULL),
  1248.       fMinCuts(DSeqPrintPrefs::gREMinCuts), 
  1249.       fMaxCuts(DSeqPrintPrefs::gREMaxCuts)
  1250. { 
  1251.   fName= "zyme";
  1252.     fFont= itsFont;
  1253.     if (fFont) Nlm_SelectFont(fFont);
  1254.     fHeight= 4 * Nlm_LineHeight(); // ! need to calc line height for each row !?
  1255.     fREMap= new DREMap();
  1256.     if (fREMap) {
  1257.         fREMap->MapSeq(fSeq);
  1258.         fCoSeq= fREMap->fCoSeq;
  1259.         fCutList= fREMap->fSeqCuts;
  1260.         }
  1261.     fGoodMap= (fREMap && fCoSeq && fCutList);
  1262. }
  1263.  
  1264. void  DDrawZymeRow::Clip( Nlm_RecT& r, short row, long startitem, long stopitem,
  1265.                                          Nlm_RecT& viewr, Nlm_RegioN cliprgn)
  1266. {
  1267.     //Nlm_ClipRgn( cliprgn);
  1268.     Nlm_RecT clipr= r;
  1269.     clipr.left= viewr.left + 10;
  1270.     clipr.right= viewr.right - 10;
  1271.     clipr.bottom= Min( r.bottom, viewr.bottom);
  1272.     clipr.top= Max(r.top, viewr.top);
  1273.     Nlm_ClipRect( &clipr);
  1274. }
  1275.  
  1276.  
  1277. #define znameCenter 0
  1278.  
  1279. short DDrawZymeRow::DrawOrMeasure( Nlm_Boolean doDraw, Nlm_RecT& r, short row, long startitem, long stopitem)
  1280. {
  1281. /*==== 
  1282.         gctcggctgctgctcggctg
  1283.                 ||        | ||
  1284.              abcI    cbaII
  1285.                                     hcgX
  1286. ====*/
  1287.  
  1288.     short        nameHeight, rowLeft, rowTop;
  1289.     short        chwidth, chleft, ncuts, cutindx;
  1290.     short        cuts, wd, ws, rowBot, lasti, i;
  1291.     Nlm_PoinT        at;
  1292.     Boolean         first,overlap;
  1293.     char             * lastzyme, * zymes;    
  1294.     Nlm_RecT        fillRect, bRect, cRect;
  1295.     Nlm_RegioN     filledArea, aRgn;
  1296.  
  1297.     if (!fGoodMap) return 0;
  1298.     cutindx = 0; //cutindx= fLastZymeCut;
  1299.     fREMap->CutsAtBase( startitem, cutindx, ncuts);    //!? don't care if startbase has no cuts
  1300.     //fLastZymeCut= cutindx; // ????
  1301.     
  1302.     if (fFont) Nlm_SelectFont(fFont); 
  1303.  
  1304.     //atcellh= col;
  1305.     nameHeight= Nlm_FontHeight(); // cHeight;
  1306.     rowTop= r.top;
  1307.     rowLeft= r.left;
  1308.     rowBot= rowTop;
  1309.     chwidth= (r.right - r.left) / (stopitem - startitem); 
  1310.     
  1311.     filledArea= Nlm_CreateRgn();
  1312.     aRgn= Nlm_CreateRgn();
  1313.     
  1314.     chleft= rowLeft + kNucSpace;
  1315.     Nlm_LoadRect( &fillRect, chleft, rowTop, chleft+1, rowTop+1);
  1316.     RectRgn( filledArea, &fillRect); //must start w/ non-empty rgn
  1317.     Nlm_MoveTo( chleft, rowTop);
  1318.     for ( i= startitem; i<=stopitem; i++) {        
  1319.         while (fCutList[cutindx].fSeqIndex < i) cutindx++;  
  1320.         first= true;
  1321.         lasti= -1; 
  1322.         lastzyme= "";
  1323.         while (fCutList[cutindx].fSeqIndex == i) {
  1324.             zymes= fCutList[cutindx].fREnzyme->fName;
  1325.             cuts = fCutList[cutindx].fREnzyme->fCutcount;
  1326.             cutindx++;
  1327.             if (cuts < fMinCuts || cuts > fMaxCuts)  goto nextZyme;  
  1328.                 //! Kludge til we fix REMap to stop dups
  1329.             if ( i==lasti && StringCmp(zymes,lastzyme)==0) goto nextZyme; 
  1330.             lasti= i; 
  1331.             lastzyme= zymes;
  1332.             
  1333.             if (first) {
  1334.                 Nlm_MoveTo( chleft, rowTop);
  1335.                 if (doDraw) Nlm_LineTo( chleft, rowTop+2/*kTicSize*/);
  1336.                 else Nlm_MoveTo( chleft, rowTop+2);
  1337.                 }
  1338.  
  1339.             ws= Nlm_StringWidth( zymes);
  1340.             wd= 2 + ws / 2;
  1341.             do {
  1342.                 Nlm_GetPen( &at);
  1343. #if znameCenter
  1344.                 Nlm_LoadRect( &cRect, at.x-wd, at.y, at.x+wd, at.y+nameHeight);
  1345. #else
  1346.                 Nlm_LoadRect( &cRect, at.x-1, at.y, at.x+ws+1, at.y+nameHeight);
  1347. #endif
  1348.                 overlap= Nlm_RectInRgn( &cRect, filledArea); 
  1349.             
  1350.                 if (doDraw && overlap && !first) {
  1351.                     //!? replace this w/ draw top to bottom of line, then overwrite zyme names 
  1352.                     Nlm_LoadRect( &bRect, at.x, at.y-nameHeight, at.x+1, at.y);
  1353.                     if (!Nlm_RectInRgn( &bRect, filledArea)) {
  1354.                         Nlm_MoveTo( chleft, at.y-nameHeight+1);
  1355.                         Nlm_LineTo( chleft, at.y);
  1356.                         }
  1357.                     }
  1358.                 first= false;
  1359.                 Nlm_MoveTo( chleft, at.y+nameHeight);
  1360.             } while (overlap);
  1361.     
  1362.             RectRgn( aRgn, &cRect);
  1363.             Nlm_UnionRgn(filledArea, aRgn, filledArea);
  1364. #if znameCenter
  1365.             Nlm_MoveTo( chleft - (ws / 2), at.y+nameHeight);
  1366. #else
  1367.             Nlm_MoveTo( chleft, at.y+nameHeight);
  1368. #endif
  1369.             if (doDraw) {
  1370.                 //TextMode(srcCopy);  //erase line overlaps...
  1371.                 Nlm_PaintString( zymes); 
  1372.                 //TextMode(srcOr);
  1373.                 }
  1374.             Nlm_GetPen( &at);
  1375.             rowBot = Max( rowBot, at.y);   
  1376. nextZyme:            
  1377.             lasti= i;
  1378.             }
  1379.             
  1380.         //spaceright();
  1381.         //chright= chleft + GetColWidth(atCellh) - fColInset;
  1382.         //chleft = chright + fColInset;
  1383.         //atcellh++;
  1384.         chleft += chwidth;
  1385.         }
  1386.     Nlm_DestroyRgn( filledArea);
  1387.     Nlm_DestroyRgn( aRgn);
  1388.     return (rowBot - rowTop + 2); //+ 12); /* lineHeight + fudge factor*/    
  1389. }
  1390.  
  1391.  
  1392.  
  1393.  
  1394. const char* DDrawZymeRow::Write( short row, short col, long startitem, long stopitem)
  1395. { 
  1396. /*==== 
  1397.         gctcggctgctgctcggctg
  1398.                 ||        | ||
  1399.              abcI    cbaII
  1400.                                     hcgX
  1401. ====*/
  1402.  
  1403.     short        chleft, ncuts, cutindx;
  1404.     short        cuts, ws, lasti;
  1405.     Boolean         first,overlap;
  1406.     char             * lastzyme, * zymes;    
  1407.  
  1408.     short    linelen;
  1409.     long  len, i, nlines, maxlines;
  1410.     char ** lines;
  1411.     short zlen, zat, atleft, atline;
  1412.  
  1413.  
  1414.     if (!fGoodMap) return 0;
  1415.     len= Min( kMaxLinebuf, stopitem-startitem);
  1416.     Nlm_MemFill( fLinebuf, ' ', kMaxLinebuf);
  1417.  
  1418.     linelen= stopitem-startitem + 5; // +2;
  1419.     maxlines= kMaxLinebuf / linelen;
  1420.     lines= (char**) MemNew( (maxlines+1) * sizeof(char*));
  1421.     for (i=0; i<maxlines; i++) lines[i]= fLinebuf + (linelen * i);
  1422.     nlines= 0;
  1423.     
  1424.     cutindx = 0; //cutindx= fLastZymeCut;
  1425.     fREMap->CutsAtBase( startitem, cutindx, ncuts);    //!? don't care if startbase has no cuts
  1426.     //fLastZymeCut= cutindx; // ????
  1427.         
  1428.     for ( i= startitem; i<=stopitem; i++) {        
  1429.         while (fCutList[cutindx].fSeqIndex < i) cutindx++;  
  1430.         first= true;
  1431.         lasti= -1; 
  1432.         lastzyme= "";
  1433.         chleft= i - startitem;
  1434.         while (fCutList[cutindx].fSeqIndex == i) {
  1435.             zymes= fCutList[cutindx].fREnzyme->fName;
  1436.             cuts = fCutList[cutindx].fREnzyme->fCutcount;
  1437.             cutindx++;
  1438.             if (cuts < fMinCuts || cuts > fMaxCuts)  goto nextZyme;  
  1439.                 //! Kludge til we fix REMap to stop dups
  1440.             if ( i==lasti && StringCmp(zymes,lastzyme)==0) goto nextZyme; 
  1441.             lasti= i; 
  1442.             lastzyme= zymes;
  1443.             
  1444.             if (first) {
  1445.                 lines[0][chleft]= '|';
  1446.                 first= false;
  1447.                 }
  1448.  
  1449.             ws= StrLen( zymes);
  1450. #if znameCenter
  1451.             wd= ws / 2;
  1452.             atleft= chleft - wd;
  1453. #else
  1454.             atleft= chleft;
  1455. #endif
  1456.             atline= 1;
  1457.             do {
  1458.               for (zlen=0, zat=atleft, overlap= false; zlen<ws; zlen++, zat++) 
  1459.                   if (lines[atline][zat] != ' ') { overlap= true; break; }
  1460.               if (overlap) atline++;
  1461.             } while (overlap && atline<maxlines);
  1462.             MemCpy( lines[atline]+atleft, zymes, ws);
  1463.             if (++atline > nlines) nlines= atline;
  1464.             first= false;
  1465.             
  1466. nextZyme:            
  1467.             lasti= i;
  1468.             }
  1469.             
  1470.         }
  1471.  
  1472.     //return  (rowBot - rowTop + 12); /* lineHeight + fudge factor*/    
  1473.  
  1474.     for (i=1; i<nlines; i++) *(lines[i]-1)= '\n';
  1475.     if (nlines) lines[nlines-1][linelen-1]= 0;
  1476.     MemFree(lines);
  1477.     fLinebuf[kMaxLinebuf]= 0;
  1478.     return fLinebuf;
  1479. }
  1480.  
  1481.  
  1482.  
  1483. short DDrawZymeRow::GetHeight( Nlm_RecT& r, short row, long startitem, long stopitem)
  1484. { 
  1485.     return DrawOrMeasure( false, r, row, startitem, stopitem);
  1486. }
  1487.  
  1488. void DDrawZymeRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  1489. {
  1490.     if (col) { startitem += col; } // ??? 
  1491.     (void) DrawOrMeasure( true, r, row, startitem, stopitem);
  1492. }
  1493.  
  1494.  
  1495.  
  1496.  
  1497.  
  1498. /******** 
  1499. methods & fields for various draw objects:
  1500.   single-seq
  1501.   multi-seq  
  1502.     single-seq [+rezymes] [+complement] [+amino-trans] [+... others]
  1503.   multi-seq  [+?consensus] [+?? annotations of various kinds for mseq ] 
  1504.   
  1505.   fSeqsPerParag
  1506.   fSeqLinesPerParag
  1507.   fSpacersPerParag
  1508.   
  1509.   DRowDrawer* GetRowDrawer( atseq):
  1510.         Spacer, TopIndex, 
  1511.         SeqLine(s), ComplSeqLine,
  1512.          AA[1-3], CompAA[1-3], RestEnzyme
  1513.   
  1514.   make fRowsList [1..fLinesPerParag] of DRowDrawer objects...
  1515.   
  1516.   calcs:
  1517.     //linesPerParag = fSeqLinesPerParag + fSpacersPerParag
  1518.     atseq  = (row % fLinesPerParag)
  1519.         seqline= (row / fLinesPerParag) * seqsperparag;  
  1520.         startcol= seqline * fBasesPerLine;
  1521.         stopcol = startcol + fBasesPerLine;
  1522. *****/
  1523.  
  1524.  
  1525.  
  1526.  
  1527.  
  1528. // class DSeqPrintView
  1529.  
  1530. class DSeqPrintView : public DTableView 
  1531. {
  1532. public:
  1533.     Boolean        fOneseq, fDoLeftName, fDoRightName, 
  1534.                         fDoTopIndex, fDoLeftIndex, fDoRightIndex; 
  1535.     Nlm_FonT    fNameFont, fNumFont, fBaseFont;
  1536.     short         fBaseWidth, fIndexWidth, fIndexWidthCnt, fNameWidth, fNameWidthCnt, 
  1537.                         fSeqsperparag, fExtrarows, fSeqLinesPerParag, fLinesPerParag, 
  1538.                         fTopPerparag, fBasesPerLine, fTenSpacer;
  1539.     long             fFirstBase, fNbases, fMaxbases, fSeqWidth;
  1540.     DSeqPrintDoc    * fDoc;
  1541.     DSeqList    * fSeqList;  
  1542.     DSequence * fSeq;
  1543.     DList            * fDrawRowList, * fStyles;
  1544.     DFile            * fFile;
  1545.     char            * fCommonbase, * fFirstcommon;
  1546.  
  1547.     //DCheckBox*        fLeftName, fRightName, fTopIndex, fLeftIndex, fRightIndex ;
  1548.     //DDlogTextView*        fStyleName, fStyleBase, fStyleNums; 
  1549.     
  1550.     DSeqPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  1551.                                  DSeqList* itsSeqList, long firstbase, long nbases,
  1552.                                  long pixwidth, long pixheight);
  1553.     virtual ~DSeqPrintView();
  1554.     virtual void Initialize();
  1555.  
  1556.     virtual void MakeDrawList();
  1557.     virtual void Draw();
  1558.     virtual void DrawRow(Nlm_RecT r, short row);
  1559.     virtual void IndexFromRow( short row, long& itemrow, long& seqline, long& startitem, long& stopitem);
  1560.     virtual void GetReadyToShow();
  1561.     virtual void DrawSideIndex( Nlm_RecT& aRect, long atBase, long leftBorder);
  1562.     virtual void WriteSideIndex( long atBase, long leftBorder);
  1563.     virtual void DrawName( Nlm_RecT& aRect, short rightBorder, char* name);
  1564.     virtual void WriteName( short rightBorder, char* name);
  1565.     virtual short GetExtraRows() { return fExtrarows; }
  1566.  
  1567.     virtual void WriteTo(DFile* aFile);
  1568.     virtual    void WriteRow(short row);
  1569. };
  1570.  
  1571.  
  1572.  
  1573. DSeqPrintView::DSeqPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  1574.                                  DSeqList* itsSeqList, long firstbase, long nbases,
  1575.                                  long pixwidth, long pixheight):
  1576.     DTableView( id, itsSuper, pixwidth, pixheight, 0, 0,  
  1577.                             Nlm_stdCharWidth, Nlm_stdLineHeight, true, true),
  1578.     fDoc(itsDocument), fSeqList(itsSeqList), fSeq(NULL), 
  1579.     fDrawRowList(NULL), fStyles(NULL),
  1580.     fCommonbase(NULL), fFirstcommon(NULL),
  1581.     fFirstBase(firstbase), fNbases(nbases), fMaxbases(nbases),
  1582.     fSeqLinesPerParag(kSeqLinesPerParag), fTopPerparag(2),
  1583.     fLinesPerParag(kSeqLinesPerParag+2), fSeqWidth(0),
  1584.     fBasesPerLine(DSeqPrintPrefs::gBasesPerLine), fExtrarows(0),
  1585.     fIndexWidth(kIndexWidth), fIndexWidthCnt(5),
  1586.     fNameWidth(kNameWidth), fNameWidthCnt(8)
  1587.  
  1588. { 
  1589.     this->SetSlateBorder( false);
  1590.     this->SetResize( DView::relsuper, DView::relsuper);
  1591.     this->SetTableFont(gTextFont);
  1592.     fBaseWidth= BaseCharWidth();
  1593.     fOneseq= fSeqList->GetSize()<2; 
  1594.     
  1595.   fSeq= (DSequence*) fSeqList->At(0);
  1596.  
  1597.     Initialize();  
  1598. }
  1599.  
  1600.  
  1601. DSeqPrintView::~DSeqPrintView()
  1602. {    
  1603.     fDrawRowList= FreeListIfObject(fDrawRowList);
  1604.     fStyles= FreeListIfObject(fStyles);
  1605.     MemFree( fCommonbase);
  1606.     MemFree( fFirstcommon);
  1607. }
  1608.  
  1609. void DSeqPrintView::Initialize()
  1610. { 
  1611.     fDoTopIndex= DSeqPrintPrefs::gIndexTop;
  1612.     fDoLeftIndex= DSeqPrintPrefs::gIndexLeft; 
  1613.     fDoRightIndex= DSeqPrintPrefs::gIndexRight;  
  1614.     fDoLeftName= DSeqPrintPrefs::gNameLeft; 
  1615.     fDoRightName= DSeqPrintPrefs::gNameRight;
  1616.     
  1617.     fNameFont = DSeqPrintPrefs::gNameFont;
  1618.     fNumFont  = DSeqPrintPrefs::gIndexFont;
  1619.     fBaseFont = DSeqPrintPrefs::gBaseFont;
  1620. }
  1621.  
  1622.  
  1623. void DSeqPrintView::MakeDrawList()
  1624. {
  1625.     short i, n;
  1626.     fDrawRowList= FreeListIfObject(fDrawRowList);
  1627.     fDrawRowList= new DList(NULL, DList::kDeleteObjects);
  1628.     fDrawRowList->InsertLast( new DDrawSpacer());
  1629.     if (fDoTopIndex) 
  1630.         fDrawRowList->InsertLast( new DDrawIndexRow(fNumFont,fBaseWidth));
  1631.  
  1632.     ulong * colors;
  1633.     //if (!fDoc->fUseColor) colors= NULL;
  1634.     if (!DSeqPrintPrefs::gColored) colors= NULL;
  1635.     else if (fSeq->Kind() == DSequence::kAmino) colors= DBaseColors::gAAcolors;
  1636.     else colors= DBaseColors::gNAcolors;
  1637.  
  1638.     fStyles= FreeListIfObject(fStyles);
  1639.     fStyles= new DList(NULL,DList::kDeleteObjects);
  1640.     n= DStyleTable::fStyles->GetSize();
  1641.     for (i=0; i<n; i++) {
  1642.         DSeqStyle    *    astyle= (DSeqStyle*) DStyleTable::fStyles->At(i);
  1643.         astyle= (DSeqStyle*) astyle->Clone();
  1644.         fStyles->InsertLast( astyle);
  1645.         }
  1646.         
  1647.     if (!fOneseq) {
  1648.         fCommonbase= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, fFirstcommon);
  1649.         for (i= 0; i < fSeqLinesPerParag; i++) {
  1650.           DDrawManySeqRow* dd= new DDrawManySeqRow( fBaseFont, this, fSeqList, i, 
  1651.                   fStyles, colors, fCommonbase, fFirstcommon);
  1652.           fDrawRowList->InsertLast(dd);
  1653.             }
  1654.         }
  1655.     else {
  1656.       for (i= 0; i < fSeqLinesPerParag; i++) { 
  1657.             DDrawSeqRow* dd= new DDrawSeqRow( fBaseFont, this, fSeq, fStyles, fSeq->Name(), colors);
  1658.           fDrawRowList->InsertLast( dd);
  1659.            }    
  1660.     }
  1661. }
  1662.  
  1663.  
  1664. void DSeqPrintView::GetReadyToShow()
  1665. {
  1666.     char nums[50];
  1667.     long diff, nrows, nbases= 0;
  1668.  
  1669.     if (fOneseq)    {
  1670.         fSeqsperparag = fSeqLinesPerParag;
  1671.         }
  1672.   else {
  1673.         fSeqLinesPerParag= fSeqList->GetSize(); //?? or leave to subclasses?
  1674.         fSeqsperparag = 1;
  1675.         }
  1676.     /* if (dospacer) */ fLinesPerParag = 1; fTopPerparag= 1;
  1677.     if (fDoTopIndex) { fLinesPerParag++; fTopPerparag++; }
  1678.     fLinesPerParag += fSeqLinesPerParag;
  1679.  
  1680. #if 1
  1681.     if (fNbases) nbases= fNbases;
  1682.     else
  1683. #endif
  1684.     if (fSeqList) {
  1685.         short i, nseq= fSeqList->GetSize();
  1686.         for (i=0; i<nseq; i++) {
  1687.             DSequence* aseq= fSeqList->SeqAt(i);
  1688.             nbases= Max(nbases, aseq->LengthF());
  1689.             }
  1690.         fNbases= nbases; 
  1691.         }
  1692.     else if (fSeq) { nbases= fSeq->LengthF(); fNbases= nbases; }
  1693.     fMaxbases= nbases;
  1694.     
  1695.     // assume port is set??
  1696.     SelectFont();
  1697.     if (fNameFont) Nlm_SelectFont(fNameFont);  
  1698.     fNameWidth= 5 + Nlm_StringWidth("Sequence");
  1699.     fNameWidthCnt= 8;
  1700.     
  1701.     if (fNumFont) Nlm_SelectFont(fNumFont);  
  1702.     sprintf( nums, "%d", fMaxbases);
  1703.     fIndexWidthCnt= StrLen(nums);
  1704.     fIndexWidth= 5 + fIndexWidthCnt * Nlm_CharWidth('0');
  1705.  
  1706.     if (fBaseFont) Nlm_SelectFont(fBaseFont);  
  1707.     fBaseWidth= BaseCharWidth();  
  1708.     
  1709.     short ncols= fBasesPerLine + 4;
  1710.     if (ncols > GetMaxCols()) ChangeColSize( -1, ncols-GetMaxCols());
  1711.  
  1712.   MakeDrawList();
  1713.  
  1714.     SetItemWidth( 0, 1, (fDoLeftName)?fNameWidth:1);
  1715.     SetItemWidth( 1, 1, (fDoLeftIndex)?fIndexWidth:1);
  1716.     SetItemWidth( 2, fBasesPerLine, fBaseWidth);  
  1717.   fSeqWidth= fBasesPerLine * fBaseWidth; //!?!?
  1718.     SetItemWidth( fBasesPerLine+2, 1, (fDoRightIndex)?fIndexWidth:1);
  1719.     SetItemWidth( fBasesPerLine+3, 1, (fDoRightName)?fNameWidth:1);
  1720.  
  1721.     nrows= 1 + (nbases / fBasesPerLine) / fSeqsperparag;
  1722.     nrows *= fLinesPerParag;
  1723.     nrows += GetExtraRows();
  1724.     diff  = Max( 3, nrows) - GetMaxRows();
  1725.     ChangeRowSize( -1, diff);  // -1 prevents redraw..else use fMaxRows    
  1726.  
  1727.     Nlm_RecT  r;
  1728.     ViewRect(r);
  1729.     nrows= GetMaxRows();  
  1730.     for (long irow=0; irow<nrows; irow++) {
  1731.         long itemrow, seqline, startitem, stopitem;
  1732.         IndexFromRow( irow, itemrow, seqline, startitem, stopitem);
  1733.         DDrawMapRow* drawer= (DDrawMapRow*) fDrawRowList->At(itemrow);
  1734.         SetItemHeight( irow, 1, 
  1735.             (drawer) ? drawer->GetHeight(r, irow, startitem, stopitem) : Nlm_stdLineHeight);
  1736.         }
  1737.         
  1738. }
  1739.  
  1740.  
  1741. void DSeqPrintView::DrawSideIndex( Nlm_RecT& aRect, long index, long leftBorder)
  1742. {
  1743.     if (index != DDrawMapRow::kNoIndex) {
  1744.         char nums[128];
  1745.         Nlm_SelectFont(fNumFont); 
  1746.         sprintf(nums, "%d", index); // or char* nump= ltoa(index);
  1747.         short atx= aRect.right - leftBorder - Nlm_StringWidth(nums);
  1748.         Nlm_MoveTo( atx, aRect.bottom - kFontDescent);
  1749.         Nlm_PaintString(nums);
  1750.         }
  1751. }
  1752.  
  1753. void DSeqPrintView::WriteSideIndex( long index, long leftBorder)
  1754. {
  1755.     char fmt[30];
  1756.     if (index != DDrawMapRow::kNoIndex) {
  1757.         if (leftBorder > 0) sprintf( fmt, " %%%dd",fIndexWidthCnt);
  1758.         else sprintf( fmt, " %%-%dd",fIndexWidthCnt);
  1759.         fprintf( fFile->fFile, fmt, index);
  1760.         }
  1761.     else {
  1762.         sprintf( fmt, " %%%ds",fIndexWidthCnt);
  1763.         fprintf( fFile->fFile, fmt, "");
  1764.         }
  1765. }
  1766.  
  1767. void DSeqPrintView::DrawName( Nlm_RecT& aRect, short rightBorder, char* name)
  1768. {
  1769.     if (name) {
  1770.         Nlm_SelectFont(fNameFont); 
  1771.         short ht= 2 * Nlm_stdLineHeight;
  1772.         if (aRect.bottom - aRect.top > ht)
  1773.             Nlm_MoveTo( aRect.left + rightBorder, aRect.top + ht);
  1774.         else     
  1775.             Nlm_MoveTo( aRect.left + rightBorder, aRect.bottom - kFontDescent);
  1776.         Nlm_PaintString( name);
  1777.         } 
  1778. }
  1779.  
  1780. void DSeqPrintView::WriteName( short rightBorder, char* name)
  1781. {
  1782.     char fmt[30];
  1783.     if (rightBorder > 0) sprintf( fmt, "  %%-%ds",fNameWidthCnt);
  1784.     else sprintf( fmt, "%%%ds ",fNameWidthCnt);
  1785.     if (!name) name= "";
  1786.     fprintf( fFile->fFile, fmt, name);
  1787. }
  1788.  
  1789.  
  1790. void DSeqPrintView::IndexFromRow( short row, long& itemrow, long& seqline, long& startitem, long& stopitem)
  1791. {
  1792.     itemrow    = (row % fLinesPerParag);  
  1793.     seqline = (row / fLinesPerParag) * fSeqsperparag;   
  1794.     if (fOneseq) seqline += Max( 0, itemrow - fTopPerparag);
  1795. #if 1
  1796.     startitem = fFirstBase + seqline * fBasesPerLine;
  1797.     stopitem  = Min(startitem + fBasesPerLine, fFirstBase+fNbases);
  1798.     if (startitem>stopitem) { startitem= stopitem; }
  1799. #else
  1800.     startitem = seqline * fBasesPerLine;
  1801.     stopitem  = startitem + fBasesPerLine;
  1802. #endif
  1803. }
  1804.  
  1805.  
  1806. void DSeqPrintView::Draw()
  1807. {
  1808. #if MASKS
  1809.             // !! toprowbases should be just CONSENSUS/Common bases, not rare ones
  1810. #if 0
  1811.     short minCommonPerCent= 70;
  1812.     char * commons= FindCommonBases( minCommonPerCent); 
  1813.      // ^^ OOPs, this is made new for each draw .. bad news
  1814.     DStyleTable::StartDraw( commons, StrLen(commons));
  1815. #else
  1816.     //DSequence* aSeq= fSeqList->SeqAt(0);
  1817.     DStyleTable::StartDraw( fSeq->Bases(), fSeq->LengthF());
  1818. #endif
  1819. #endif
  1820.  
  1821.     DTableView::Draw();
  1822.     
  1823. #if MASKS
  1824.     DStyleTable::EndDraw();
  1825. #endif
  1826. }
  1827.  
  1828. void DSeqPrintView::DrawRow(Nlm_RecT r, short row)
  1829. {
  1830.     long             itemrow, seqline, startitem, stopitem;
  1831.     short         col, ncols;
  1832.     Nlm_RecT    r1, viewr;
  1833.     Nlm_RegioN     cliprgn;
  1834.     DDrawMapRow * drawer;
  1835.     
  1836.     col = GetLeft(); 
  1837.     if (fWidths && col <= fMaxCols) r.right= r.left + fWidths[col];
  1838.     else r.right= r.left + fItemWidth;
  1839.     ViewRect( viewr);
  1840.  
  1841.     IndexFromRow( row, itemrow, seqline, startitem, stopitem);
  1842.   cliprgn= Nlm_CreateRgn();
  1843.     drawer= (DDrawMapRow*) fDrawRowList->At(itemrow);
  1844.   
  1845.     if (drawer) {
  1846.         drawer->fItemrow= itemrow - fTopPerparag;// so we know which seq line in array
  1847.         while (r.left < fRect.right && col < fMaxCols) {
  1848.             if (col < 2 || col > fBasesPerLine+1) {
  1849.                         // do name & index borders
  1850.                 ncols= 1;
  1851.                 if (col == 0 && !fDoLeftName && drawer->DoLeftName()) // special case, fiddle w/ clip rgn...
  1852.                     { r.right += fItemWidth; }
  1853.                 (void) Nlm_SectRect( &r, &viewr, &r1);
  1854.                 RectRgn( cliprgn, &r1);  
  1855.                 Nlm_SectRgn( cliprgn, Nlm_updateRgn, cliprgn);
  1856.                 if ( !Nlm_EmptyRgn( cliprgn)) {
  1857.                     Nlm_ClipRgn(cliprgn);
  1858.                     r1= r;
  1859.                     if (col == 0) {
  1860.                         if (fDoLeftName || drawer->DoLeftName()) DrawName( r1, 0, drawer->GetName(row));
  1861.                         }
  1862.                     else if (col == 1) {
  1863.                         if (fDoLeftIndex) DrawSideIndex( r1, drawer->GetIndex(startitem), kNucBorder);
  1864.                         }
  1865.                     else if (col == fBasesPerLine+2) {
  1866.                         if (fDoRightIndex) DrawSideIndex( r1,  drawer->GetIndex(stopitem), 0);
  1867.                         }
  1868.                     else if (col == fBasesPerLine+3) {
  1869.                         if (fDoRightName) DrawName( r1, kNucBorder, drawer->GetName(row));        
  1870.                         }    
  1871.                     }
  1872.                 }
  1873.                 
  1874.             else if (col < fBasesPerLine+2) {
  1875.                 r.right= r.left + fSeqWidth;
  1876.                 ncols= fBasesPerLine; //stopitem - startitem;
  1877.                 (void) Nlm_SectRect( &r, &viewr, &r1);
  1878.                 RectRgn( cliprgn, &r1);  
  1879.                 Nlm_SectRgn( cliprgn, Nlm_updateRgn, cliprgn);
  1880.                 if ( !Nlm_EmptyRgn( cliprgn)) {
  1881.                     r1= r;
  1882.                     //Nlm_ClipRgn(cliprgn);
  1883.                     //drawer->fItemrow= itemrow - fTopPerparag;// so we know which seq line in array
  1884.                     drawer->Clip( r1, row, startitem, stopitem, viewr, cliprgn);
  1885.                     drawer->Draw( r1, row, col-2, startitem, stopitem);
  1886.                     }
  1887.                 }
  1888.         
  1889.           col += ncols;
  1890.             r.left= r.right;
  1891.             if (fWidths) r.right += fWidths[col];
  1892.             else r.right += fItemWidth;
  1893.             }
  1894.         }
  1895.     //Nlm_ClipRgn(Nlm_updateRgn);
  1896.     fColsDrawn= col - GetLeft();
  1897.     Nlm_ResetClip();
  1898.     Nlm_DestroyRgn(cliprgn);
  1899. }
  1900.  
  1901.  
  1902. void DSeqPrintView::WriteTo(DFile* aFile)
  1903. {
  1904.     if (aFile) {
  1905.         long irow, nrows;
  1906.         fFile= aFile;
  1907.         fFile->Open("a");
  1908.         nrows= GetMaxRows();  
  1909.         for (irow=0; irow<nrows; irow++) WriteRow( irow);
  1910.         fFile->Close();
  1911.         }
  1912. }
  1913.  
  1914. void DSeqPrintView::WriteRow(short row)
  1915. {
  1916.     long             itemrow, seqline, startitem, stopitem;
  1917.     short         col, ncols;
  1918.     DDrawMapRow * drawer;
  1919.     char * newline, * atline;
  1920.     
  1921.     IndexFromRow( row, itemrow, seqline, startitem, stopitem);
  1922.     drawer= (DDrawMapRow*) fDrawRowList->At(itemrow);
  1923.     if (!drawer) return;
  1924.     drawer->fItemrow= itemrow - fTopPerparag;// so we know which seq line in array
  1925.  
  1926.     atline= (char*) drawer->Write( row, 0, startitem, stopitem);
  1927.     while (atline) {
  1928.         newline= StrChr(atline, '\n');
  1929.         if (newline) *newline++= 0; // risky: (const char*) drawer->Write()
  1930.         
  1931.         for (col=0, ncols=1; col<fMaxCols; col += ncols) {
  1932.             if (col < 2 || col > fBasesPerLine+1) {
  1933.                         // do name & index borders
  1934.                 ncols= 1;
  1935.                 if (col == 0) {
  1936.                     if (fDoLeftName || drawer->DoLeftName()) WriteName(  0, drawer->GetName(row));
  1937.                     }
  1938.                 else if (col == 1) {
  1939.                     if (fDoLeftIndex) WriteSideIndex( drawer->GetIndex(startitem), kNucBorder);
  1940.                     }
  1941.                 else if (col == fBasesPerLine+2) {
  1942.                     if (fDoRightIndex) WriteSideIndex(  drawer->GetIndex(stopitem), 0);
  1943.                     }
  1944.                 else if (col == fBasesPerLine+3) {
  1945.                     if (fDoRightName) WriteName(  kNucBorder, drawer->GetName(row));        
  1946.                     }    
  1947.                 }
  1948.             else {
  1949.                 ncols= fBasesPerLine; 
  1950.                 fFile->WriteLine( " ", false);
  1951.                 fFile->WriteLine( atline, false);
  1952.                 }
  1953.             }
  1954.             
  1955.         atline= newline;
  1956.         fFile->WriteLine("\n");
  1957.         }
  1958. }
  1959.  
  1960.  
  1961.  
  1962.  
  1963.  
  1964.  
  1965.  
  1966.  
  1967.  
  1968. // class DSeqPrintDoc
  1969.  
  1970.  
  1971. Nlm_RecT DSeqPrintDoc::fgPrWinRect = { 0, 0, 0, 0 };
  1972.  
  1973. DSeqPrintDoc::DSeqPrintDoc( long id, DSeqDoc* itsDoc, DSeqList* itsSeqList, long firstbase, long nbases) :
  1974.         DWindow( kSeqPrintDoc, gApplication),
  1975.         fView(NULL),  
  1976.         fSeqList(itsSeqList),
  1977.         fFirstBase(firstbase), fNbases(nbases),
  1978.         //fHeadline(NULL), fFormatPop(NULL),
  1979.         //fLockButton(NULL), fColorButton(NULL), fMonoButton(NULL),
  1980.         fColorCheck(NULL), fLockCheck(NULL), 
  1981.         fUseColor(itsDoc->fUseColor)
  1982. { 
  1983.     short width= -1, height= -1, left= -10, top= -20; // default window loc
  1984.     if (id != 0) fId= id;
  1985.     
  1986.     //gTextFont = Nlm_GetFont( "Courier", 10, false, false, false, "Fixed");
  1987.     //if (gTextFont == NULL) gTextFont= Nlm_programFont;
  1988.  
  1989.     if (!Nlm_EmptyRect(&fgPrWinRect))  {
  1990.         left= MAX(20,fgPrWinRect.left);
  1991.         top = MAX(40,fgPrWinRect.top);
  1992.         }
  1993.     
  1994.     char * winname= NULL;
  1995.     this->InitWindow( document, width, height, left, top); //, winname); 
  1996.  
  1997.     DSequence * aSeq;
  1998.     char title[256];
  1999.     if (!fSeqList) {
  2000.         fSeqList= new DSeqList();  
  2001.         fSeqList->AddNewSeq();    // install 1 blank seq for new doc
  2002.         aSeq= NULL;
  2003.         }
  2004.     else {
  2005.       aSeq= (DSequence*) fSeqList->At(0);
  2006.         }
  2007.     if (aSeq)  
  2008.         StrCpy(title, aSeq->Name());
  2009.     else
  2010.         itsDoc->GetTitle( title, sizeof(title)); 
  2011.     StrCat( title, " Print");
  2012.     SetTitle( title);
  2013. }
  2014.  
  2015.  
  2016. DSeqPrintDoc::~DSeqPrintDoc()
  2017. {
  2018.     if (fSeqList) { 
  2019.         // we don't own DSeq objects in this list !!
  2020.         //fSeqList->FreeAllObjects(); 
  2021.         fSeqList->suicide(); 
  2022.         }
  2023. }
  2024.  
  2025.  
  2026. void DSeqPrintDoc::MakeGlobalsCurrent()
  2027. {
  2028.     ViewRect( fViewrect); // get current rect...
  2029.     if (!Nlm_EmptyRect(&fViewrect)) fgPrWinRect= fViewrect;  
  2030.     //fgUseColor= fColorCheck->GetStatus();
  2031. }
  2032.  
  2033. void DSeqPrintDoc::Close()
  2034. {
  2035.     MakeGlobalsCurrent();
  2036.     DWindow::Close();
  2037. }
  2038.  
  2039. void DSeqPrintDoc::ResizeWin()
  2040. {
  2041.     DWindow::ResizeWin();
  2042.     MakeGlobalsCurrent();
  2043. }
  2044.  
  2045.  
  2046. // static
  2047. void DSeqPrintDoc::GetGlobals()
  2048. {
  2049.  
  2050.     //char* onoffs= (fgUseColor) ? "1" : "0";
  2051.     //fgUseColor= gApplication->GetPrefVal( "fgUseColor", "windows", onoffs);
  2052.     {
  2053.     char* srect = gApplication->GetPref( "fgPrWinRect", "windows", "30 40 450 220");
  2054. #if 1
  2055.         // sscanf is failing on Mac/codewar !! used to work
  2056.     if (srect) {
  2057.         char* cp= srect;
  2058.         while (*cp && isspace(*cp)) cp++;
  2059.         fgPrWinRect.left= atoi( cp);
  2060.         
  2061.         while (*cp && !isspace(*cp)) cp++;
  2062.         while (*cp && isspace(*cp)) cp++;
  2063.         fgPrWinRect.top= atoi( cp);
  2064.         
  2065.         while (*cp && !isspace(*cp)) cp++;
  2066.         while (*cp && isspace(*cp)) cp++;
  2067.         fgPrWinRect.right= atoi( cp);
  2068.         
  2069.         while (*cp && !isspace(*cp)) cp++;
  2070.         while (*cp && isspace(*cp)) cp++;
  2071.         fgPrWinRect.bottom= atoi( cp);
  2072.         }
  2073. #else
  2074.         if (srect) sscanf( srect, "%d%d%d%d", &fgPrWinRect.left, &fgPrWinRect.top, 
  2075.                                                 &fgPrWinRect.right, &fgPrWinRect.bottom);
  2076. #endif
  2077.         Nlm_MemFree(srect);
  2078.     }
  2079. }
  2080.  
  2081. // static
  2082. void DSeqPrintDoc::SaveGlobals()
  2083. {
  2084.     //gApplication->SetPref( (int) fgUseColor, "fgUseColor","windows");
  2085.     if (!Nlm_EmptyRect(&fgPrWinRect)) {
  2086.         char  srect[128];
  2087.         sprintf( srect, "%d %d %d %d", fgPrWinRect.left, fgPrWinRect.top, 
  2088.                                                         fgPrWinRect.right, fgPrWinRect.bottom);
  2089.         gApplication->SetPref( srect, "fgPrWinRect", "windows");
  2090.         }
  2091. }
  2092.  
  2093.  
  2094. void DSeqPrintDoc::Open()
  2095. {
  2096.     DView*     super;
  2097.     short width, height;
  2098.     Nlm_PoinT        nps;
  2099.     
  2100.     //if (!fSeqList) fSeqList= new DSeqList();
  2101.     if (!fView) {
  2102.         super= this;
  2103.     
  2104.         width= 450; height= 350;
  2105.         super->GetNextPosition( &nps);
  2106.         width = MAX( 40, fgPrWinRect.right - fgPrWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  2107.         height= MAX( 60, fgPrWinRect.bottom - fgPrWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  2108.         fView= new DSeqPrintView(0,super,this,fSeqList,fFirstBase,fNbases,width,height);
  2109.         }
  2110.  
  2111.     fSaveHandler= this;  
  2112.     fPrintHandler= this;
  2113.     
  2114.     this->Select(); // for motif
  2115.     this->CalcWindowSize();
  2116.     fView->GetReadyToShow();
  2117.     
  2118.     DWindow::Open();
  2119. }
  2120.  
  2121.  
  2122.  
  2123.  
  2124. void DSeqPrintDoc::WriteTo(DFile* aFile)  
  2125. {
  2126.         // offer user choice of Text or PICT (or other? - PS) output
  2127.         // need popup choice in save-as dialog...
  2128.     if (gKeys->shift())
  2129.         fView->WriteTo( aFile); // TEXT
  2130.     else
  2131.         fView->WriteToPICT( aFile); // PICT
  2132. }
  2133.  
  2134.  
  2135. void DSeqPrintDoc::Print()  
  2136. {
  2137.     fView->Print();
  2138. }
  2139.  
  2140.  
  2141.  
  2142.  
  2143.  
  2144.  
  2145.  
  2146.  
  2147.  
  2148.  
  2149.  
  2150.  
  2151. // class DAlnPrintView
  2152.  
  2153. class DAlnPrintView : public DSeqPrintView {
  2154. public:
  2155.  
  2156.     DAlnPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  2157.                                  DSeqList* itsSeqList, long firstbase, long nbases, long pixwidth, long pixheight);
  2158. };
  2159.  
  2160. DAlnPrintView::DAlnPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  2161.                                  DSeqList* itsSeqList, long firstbase, long nbases, long pixwidth, long pixheight):
  2162.         DSeqPrintView( id, itsSuper, itsDocument, itsSeqList, firstbase, nbases, pixwidth, pixheight)
  2163. { 
  2164.     fSeqLinesPerParag= fSeqList->GetSize();
  2165. }
  2166.  
  2167. // class DAlnPrintDoc
  2168.  
  2169. DAlnPrintDoc::DAlnPrintDoc( long id, DSeqDoc* itsDoc, DSeqList* itsSeqList, long firstbase, long nbases) :
  2170.     DSeqPrintDoc( id, itsDoc, itsSeqList, firstbase, nbases)
  2171. {
  2172.  
  2173.     short width= 450, height= 350;
  2174.     //super->GetNextPosition( &nps);
  2175.     //width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  2176.     //height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  2177.     fView= new DAlnPrintView(0,this,this,fSeqList,fFirstBase,fNbases,width,height);
  2178.  
  2179.     char title[256];
  2180.     itsDoc->GetTitle( title, sizeof(title)); 
  2181.     StrCat( title, " Print");
  2182.     SetTitle( title);
  2183. }
  2184.  
  2185.  
  2186.  
  2187.  
  2188.  
  2189.  
  2190.  
  2191.  
  2192.  
  2193. // class DREMapPrintView
  2194.  
  2195. class DREMapPrintView : public DSeqPrintView {
  2196. public:
  2197.     Boolean fDoAAline[6];
  2198.     Boolean fDoSeqLine,fDoMidIndex,fDoCoseqLine,fDoZymeLine;
  2199.     short        fMaxseqrow;
  2200.     
  2201.     DREMapPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  2202.                     DSeqList* itsSeqList, long firstbase, long nbases, long pixwidth, long pixheight);
  2203.     virtual void Initialize();
  2204.     virtual void MakeDrawList();
  2205.     virtual void SetScrollPage();
  2206.     virtual void IndexFromRow( short row, long& itemrow, long& seqline, long& startitem, long& stopitem);
  2207. };
  2208.  
  2209.  
  2210.  
  2211. DREMapPrintView::DREMapPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  2212.                                  DSeqList* itsSeqList, long firstbase, long nbases, long pixwidth, long pixheight):
  2213.     DSeqPrintView( id, itsSuper, itsDocument, itsSeqList, firstbase, 
  2214.                             nbases, pixwidth, pixheight)
  2215. { 
  2216.     Initialize();
  2217. }
  2218.  
  2219. void DREMapPrintView::IndexFromRow( short row, long& itemrow, long& seqline, long& startitem, long& stopitem)
  2220. {
  2221.         // !! modify itemrow to return drawer item row for tables after all of sequence as been drawn
  2222.   if (row > fMaxseqrow) {
  2223. #if 1
  2224.         short i, n = fDrawRowList->GetSize();
  2225.         itemrow= fLinesPerParag;
  2226.     seqline= row - fMaxseqrow - 2; //??
  2227.         for (i= fLinesPerParag; i<n; i++) {
  2228.             DDrawMapRow* drawer= (DDrawMapRow*) fDrawRowList->At(i);
  2229.             if (drawer && 
  2230.                   row >= drawer->fRowOffset && row < drawer->fRowOffset + drawer->fLinecount) { 
  2231.                   itemrow= i;
  2232.                   seqline= row - drawer->fRowOffset; //??
  2233.                   break; 
  2234.                     }
  2235.             }
  2236. #else
  2237.     itemrow= fLinesPerParag; // need to adjust this for each spacer, etc...
  2238.       if (row > fMaxseqrow + 1) itemrow++;
  2239.     seqline= row - fMaxseqrow - 2; //??
  2240. #endif
  2241.         startitem = seqline;
  2242.         stopitem  = startitem+1; //??
  2243.       }
  2244.   else {
  2245.         itemrow    = (row % fLinesPerParag);  
  2246.         seqline = (row / fLinesPerParag) * fSeqsperparag;   
  2247.         if (fOneseq) seqline += Max( 0, itemrow - fTopPerparag);
  2248. #if 1
  2249.         startitem = fFirstBase + seqline * fBasesPerLine;
  2250.         stopitem  = Min(startitem + fBasesPerLine, fFirstBase+fNbases);
  2251. #else
  2252.         startitem = seqline * fBasesPerLine;
  2253.         stopitem  = startitem + fBasesPerLine;
  2254. #endif
  2255.         }
  2256. }
  2257.  
  2258. void DREMapPrintView::Initialize()
  2259. {
  2260.     DSeqPrintView::Initialize();
  2261.  
  2262.     fSeqLinesPerParag= 1;
  2263.     fOneseq= false;
  2264.     fDoMidIndex= fDoTopIndex;
  2265.     fDoTopIndex= false;
  2266.     fDoSeqLine= true;
  2267.     fDoCoseqLine= DSeqPrintPrefs::gShowComplement;
  2268.     fDoZymeLine= true;
  2269.   
  2270.     fDoAAline[0]= DSeqPrintPrefs::gShowAA1;
  2271.     fDoAAline[1]= DSeqPrintPrefs::gShowAA2;
  2272.     fDoAAline[2]= DSeqPrintPrefs::gShowAA3;
  2273.     fDoAAline[3]= DSeqPrintPrefs::gShowCompAA1;
  2274.     fDoAAline[4]= DSeqPrintPrefs::gShowCompAA2;
  2275.     fDoAAline[5]= DSeqPrintPrefs::gShowCompAA3;    
  2276.     
  2277. }
  2278.  
  2279. void DREMapPrintView::SetScrollPage()
  2280. {
  2281.     fItemHeight= Nlm_stdLineHeight;
  2282.     DTableView::SetScrollPage();
  2283. }
  2284.  
  2285. void DREMapPrintView::MakeDrawList()
  2286. {
  2287.     short i, n;
  2288.     ulong * colors = NULL;
  2289.     DDrawZymeRow * zymerow = NULL;
  2290.     DSequence* coseq = NULL;
  2291.     Boolean anyamino;
  2292.     
  2293.     fDrawRowList= FreeListIfObject(fDrawRowList);
  2294.     fDrawRowList= new DList(NULL, DList::kDeleteObjects);
  2295.     fDrawRowList->InsertLast(new DDrawSpacer());
  2296.     if (fDoTopIndex) 
  2297.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth));
  2298.  
  2299.     if (fDoZymeLine) {
  2300.         fSeq->SetSelection(fFirstBase, fNbases);  // !? zyme map for only selected section
  2301.         zymerow= new DDrawZymeRow( fNameFont, fSeq);
  2302.         if (zymerow) {
  2303.             if (!zymerow->fGoodMap) { delete zymerow; zymerow= NULL; }
  2304.             else coseq= zymerow->fCoSeq;
  2305.             }
  2306.         }
  2307.     else if (fDoCoseqLine) {
  2308.         fSeq->SetSelection(0,0); // for Complement...
  2309.         coseq= fSeq->Complement();
  2310.         }
  2311.     
  2312.     anyamino= false;
  2313.     for (i=0; i<6; i++) if (fDoAAline[i]) anyamino= true;
  2314.  
  2315.     fStyles= FreeListIfObject(fStyles);
  2316.     fStyles= new DList(NULL,DList::kDeleteObjects);
  2317.     n= DStyleTable::fStyles->GetSize();
  2318.     for (i=0; i<n; i++) fStyles->InsertLast( DStyleTable::fStyles->At(i));
  2319.     
  2320. #if 1
  2321.     /* if (dospacer) */ fLinesPerParag = 1; fTopPerparag= 1;
  2322.     if (fDoTopIndex) { fLinesPerParag++; fTopPerparag++; }
  2323.     if (fDoSeqLine)
  2324.         fDrawRowList->InsertLast( 
  2325.             new DDrawSeqRow( fBaseFont, this, fSeq, fStyles, fSeq->Name(), colors));
  2326.     if (fDoSeqLine) { fLinesPerParag++;  }
  2327.     if (fDoMidIndex) 
  2328.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth,false));
  2329.     if (fDoMidIndex) { fLinesPerParag++;  }
  2330.     if (fDoCoseqLine && coseq)
  2331.         fDrawRowList->InsertLast( 
  2332.             new DDrawSeqRow( fBaseFont, this, coseq, fStyles, "compl", colors));
  2333.     if (fDoCoseqLine && coseq) { fLinesPerParag++;}
  2334.     if (fDoZymeLine && zymerow)
  2335.         fDrawRowList->InsertLast( zymerow);
  2336.     if (fDoZymeLine && zymerow) { fLinesPerParag++; }
  2337.     if (anyamino)
  2338.         fDrawRowList->InsertLast(new DDrawSpacer()); fLinesPerParag++;
  2339.         
  2340.     for (i= 0; i<3; i++) if (fDoAAline[i])
  2341.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, fSeq, i));
  2342.     for (i= 0; i<3; i++) if (fDoAAline[i]) { fLinesPerParag++;  }
  2343.     if (fDoMidIndex) 
  2344.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth,false));
  2345.     if (fDoMidIndex) { fLinesPerParag++;  }
  2346.     for (i= 3; i<6; i++) if (fDoAAline[i] && coseq)
  2347.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, coseq, i));
  2348.     for (i= 3; i<6; i++) if (fDoAAline[i]) fLinesPerParag++;
  2349.  
  2350.     fDrawRowList->InsertLast(new DDrawSpacer()); fLinesPerParag++;
  2351.     
  2352. #else
  2353.     for (i= 0; i<3; i++) if (fDoAAline[i])
  2354.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, fSeq, i));
  2355.     if (fDoSeqLine)
  2356.         fDrawRowList->InsertLast( 
  2357.             new DDrawSeqRow( fBaseFont, this, fSeq, fStyles, fSeq->Name(), colors));
  2358.     if (fDoMidIndex) 
  2359.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth,false));
  2360.     if (fDoMidIndex) { fLinesPerParag++;  }
  2361.     if (fDoCoseqLine && coseq)
  2362.         fDrawRowList->InsertLast( 
  2363.             new DDrawSeqRow( fBaseFont, this, coseq, fStyles, "compl", colors));
  2364.     for (i= 3; i<6; i++) if (fDoAAline[i] && coseq)
  2365.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, coseq, i));
  2366.     if (fDoZymeLine && zymerow)
  2367.         fDrawRowList->InsertLast( zymerow);
  2368.     /* if (dospacer) */ fLinesPerParag = 1; fTopPerparag= 1;
  2369.     if (fDoTopIndex) { fLinesPerParag++; fTopPerparag++; }
  2370.     for (i= 0; i<3; i++) if (fDoAAline[i]) { fLinesPerParag++; fTopPerparag++; }
  2371.     if (fDoSeqLine) { fLinesPerParag++;  }
  2372.     if (fDoCoseqLine && coseq) { fLinesPerParag++;}
  2373.     for (i= 3; i<6; i++) if (fDoAAline[i]) fLinesPerParag++;
  2374.     if (fDoZymeLine) { fLinesPerParag++; }
  2375. #endif
  2376.  
  2377.     fMaxseqrow= 1 + (fMaxbases / fBasesPerLine);
  2378.     fMaxseqrow *= fLinesPerParag;
  2379.     if (zymerow && DSeqPrintPrefs::gShowCutpoints) {
  2380.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  2381.         DDrawZymeCutTable* ztab= new DDrawZymeCutTable( gTextFont/*fNumFont*/,  
  2382.                                                                     zymerow->fREMap, fMaxseqrow+fExtrarows);  
  2383.         fDrawRowList->InsertLast( ztab);  
  2384.     fExtrarows += ztab->fLinecount + 1;
  2385.     }
  2386.     if (zymerow && DSeqPrintPrefs::gShowAllZymes) {
  2387.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  2388.         DDrawAllZymeTable* ztab= new DDrawAllZymeTable( gTextFont, zymerow->fREMap, 
  2389.                                                                         fMaxseqrow+fExtrarows);  
  2390.         fDrawRowList->InsertLast( ztab);  
  2391.     fExtrarows += ztab->fLinecount + 1;
  2392.     }
  2393.     if (zymerow && DSeqPrintPrefs::gShowNoncutters) {
  2394.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  2395.         DDrawNocutZymeTable* ztab= new DDrawNocutZymeTable( gTextFont, zymerow->fREMap, 
  2396.                                                                         fMaxseqrow+fExtrarows);  
  2397.         fDrawRowList->InsertLast( ztab);  
  2398.     fExtrarows += ztab->fLinecount + 1;
  2399.     }
  2400.     if (zymerow && DSeqPrintPrefs::gShowExcludedCutters) {
  2401.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  2402.         DDrawNocutZymeTable* ztab= new DDrawNocutZymeTable( gTextFont, zymerow->fREMap, 
  2403.                                                                         fMaxseqrow+fExtrarows, 
  2404.                                                                         DSeqPrintPrefs::gREMinCuts,
  2405.                                                                         DSeqPrintPrefs::gREMaxCuts);  
  2406.         fDrawRowList->InsertLast( ztab);  
  2407.     fExtrarows += ztab->fLinecount + 1;
  2408.     }
  2409.      
  2410. }
  2411.  
  2412.  
  2413.  
  2414. // class DREMapPrintDoc
  2415.  
  2416. DREMapPrintDoc::DREMapPrintDoc( long id, DSeqDoc* itsDoc, DSeqList* itsSeqList, long firstbase, long nbases) :
  2417.     DSeqPrintDoc( id, itsDoc, itsSeqList, firstbase, nbases)
  2418. {
  2419.     short width= 450, height= 350;
  2420.     //super->GetNextPosition( &nps);
  2421.     //width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  2422.     //height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  2423.     fView= new DREMapPrintView(0,this,this,fSeqList,fFirstBase,fNbases,width,height);
  2424.  
  2425.     char title[256];
  2426.     DSequence * aSeq= (DSequence*) fSeqList->At(0);
  2427.     if (aSeq)  
  2428.         StrCpy(title, aSeq->Name());
  2429.     else
  2430.         itsDoc->GetTitle( title, sizeof(title)); 
  2431.     StrCat( title, " Restr. Map");
  2432.     SetTitle( title);
  2433. }
  2434.  
  2435.  
  2436.  
  2437.  
  2438.  
  2439.  
  2440.  
  2441.  
  2442.  
  2443.  
  2444.  
  2445.  
  2446. //class DSeqPrintPrefs : public DWindow 
  2447.  
  2448.  
  2449.  
  2450. DSeqPrintPrefs::DSeqPrintPrefs() :
  2451.     DWindow( 0, NULL, DWindow::fixed, -10, -10, -50, -20, "SeqPrint prefs", kDontFreeOnClose),
  2452.     fNameFontMenu(NULL), fBaseFontMenu(NULL),  fIndexFontMenu(NULL),
  2453.     fNameStyleMenu(NULL), fBaseStyleMenu(NULL),  fIndexStyleMenu(NULL),
  2454.     fNameSizeSw(NULL), fBaseSizeSw(NULL),  fIndexSizeSw(NULL),
  2455.     fREMinCuts(NULL),  fREMaxCuts(NULL), fBasePerLine(NULL),
  2456.     fNeedSave(false)
  2457. {    
  2458. }
  2459.  
  2460. DSeqPrintPrefs::~DSeqPrintPrefs()
  2461. {
  2462. }
  2463.  
  2464.  
  2465. inline Nlm_FonT GetAFont( char* fname, short fsize, short fstyle)
  2466. {
  2467.     if (StrICmp(fname,"System")==0) return Nlm_systemFont;
  2468.     else if (StrICmp(fname,"Program")==0) return Nlm_programFont;
  2469.     else return Nlm_GetFont( fname, fsize, 
  2470.              fstyle & kBold, fstyle & kItalic, fstyle & kUnderline, NULL);
  2471. }
  2472.  
  2473. // static
  2474. void DSeqPrintPrefs::InitGlobals() 
  2475. { 
  2476.  
  2477.     gNameFontName= gApplication->GetPref( "gNameFontName", "fonts", gNameFontName);
  2478.     gNameFontSize= gApplication->GetPrefVal( "gNameFontSize", "fonts", "10");
  2479.     gNameStyle= gApplication->GetPrefVal( "gNameStyle", "fonts", "0");
  2480.     gNameFont= ::GetAFont(gNameFontName,gNameFontSize, gNameStyle);
  2481.  
  2482.     gBaseFontName= gApplication->GetPref( "gBaseFontName", "fonts", gBaseFontName);
  2483.     gBaseFontSize= gApplication->GetPrefVal( "gBaseFontSize", "fonts", "10");
  2484.     gBaseStyle= gApplication->GetPrefVal( "gBaseStyle", "fonts", "0");
  2485.     gBaseFont= ::GetAFont(gBaseFontName,gBaseFontSize, gBaseStyle);
  2486.  
  2487.     gIndexFontName= gApplication->GetPref( "gIndexFontName", "fonts", gIndexFontName);
  2488.     gIndexFontSize= gApplication->GetPrefVal( "gIndexFontSize", "fonts", "9");
  2489.     gIndexStyle= gApplication->GetPrefVal( "gIndexStyle", "fonts", "0");
  2490.     gIndexFont= ::GetAFont(gIndexFontName,gIndexFontSize, gIndexStyle);
  2491.     
  2492.     gNameLeft= gApplication->GetPrefVal( "gNameLeft", "seqprint","0");
  2493.     gNameRight= gApplication->GetPrefVal( "gNameRight", "seqprint","1");
  2494.     gIndexLeft= gApplication->GetPrefVal( "gIndexLeft", "seqprint","1");
  2495.     gIndexRight= gApplication->GetPrefVal( "gIndexRight", "seqprint","0");
  2496.     gIndexTop= gApplication->GetPrefVal( "gIndexTop", "seqprint","1");
  2497.     gColored= gApplication->GetPrefVal( "gColored", "seqprint","1");
  2498.     gBasesPerLine= gApplication->GetPrefVal( "gBasesPerLine", "seqprint","60");
  2499.   
  2500.     gShowComplement= gApplication->GetPrefVal( "gShowComplement", "seqprint","1");
  2501.     gThreeLetAA= gApplication->GetPrefVal( "gThreeLetAA", "seqprint","0");
  2502.     gOnlyORF= gApplication->GetPrefVal( "gOnlyORF", "seqprint","0");
  2503.     gShowAA1= gApplication->GetPrefVal( "gShowAA1", "seqprint","0");
  2504.     gShowAA2= gApplication->GetPrefVal( "gShowAA2", "seqprint","0");
  2505.     gShowAA3= gApplication->GetPrefVal( "gShowAA3", "seqprint","0");
  2506.     gShowCompAA1= gApplication->GetPrefVal( "gShowCompAA1", "seqprint","0");
  2507.     gShowCompAA2= gApplication->GetPrefVal( "gShowCompAA2", "seqprint","0");
  2508.     gShowCompAA3= gApplication->GetPrefVal( "gShowCompAA3", "seqprint","0");
  2509.  
  2510.     gShowAllZymes= gApplication->GetPrefVal( "gShowAllZymes", "remap","0");
  2511.     gShowCutpoints= gApplication->GetPrefVal( "gShowCutpoints", "remap","0");
  2512.     gShowNoncutters= gApplication->GetPrefVal( "gShowNoncutters", "remap","0");
  2513.     gShowExcludedCutters= gApplication->GetPrefVal( "gShowExcludedCutters", "remap","0");
  2514.  
  2515.     gREMinCuts= gApplication->GetPrefVal( "gREMinCuts", "remap","1");
  2516.     gREMaxCuts= gApplication->GetPrefVal( "gREMaxCuts", "remap","999");
  2517.  
  2518. #if 0
  2519.     {
  2520.     char* srect = gApplication->GetPref( "gSeqPrintDocRect", "windows", "20 20 450 220");
  2521.         // sscanf is failing on Mac/codewar !? used to work
  2522.     if (srect) {
  2523.         char* cp= srect;
  2524.         while (*cp && isspace(*cp)) cp++;
  2525.         gSeqPrintDocRect.left= atoi( cp);
  2526.         
  2527.         while (*cp && !isspace(*cp)) cp++;
  2528.         while (*cp && isspace(*cp)) cp++;
  2529.         gSeqPrintDocRect.top= atoi( cp);
  2530.         
  2531.         while (*cp && !isspace(*cp)) cp++;
  2532.         while (*cp && isspace(*cp)) cp++;
  2533.         gSeqPrintDocRect.right= atoi( cp);
  2534.         
  2535.         while (*cp && !isspace(*cp)) cp++;
  2536.         while (*cp && isspace(*cp)) cp++;
  2537.         gSeqPrintDocRect.bottom= atoi( cp);
  2538.         }
  2539.     MemFree(srect);
  2540.     }    
  2541. #endif
  2542.  
  2543. }
  2544.  
  2545.  
  2546. //static
  2547. void DSeqPrintPrefs::SaveGlobals() 
  2548. {
  2549.     gApplication->SetPref( gNameFontName, "gNameFontName", "fonts");
  2550.     gApplication->SetPref( gNameFontSize, "gNameFontSize", "fonts");
  2551.     gApplication->SetPref( gNameStyle, "gNameStyle", "fonts");
  2552.     gApplication->SetPref( gBaseFontName, "gBaseFontName", "fonts");
  2553.     gApplication->SetPref( gBaseFontSize, "gBaseFontSize", "fonts");
  2554.     gApplication->SetPref( gBaseStyle, "gBaseStyle", "fonts");
  2555.     gApplication->SetPref( gIndexFontName, "gIndexFontName", "fonts");
  2556.     gApplication->SetPref( gIndexFontSize, "gIndexFontSize", "fonts");
  2557.     gApplication->SetPref( gIndexStyle, "gIndexStyle", "fonts");
  2558.     
  2559.     gApplication->SetPref( gNameLeft, "gNameLeft", "seqprint");
  2560.     gApplication->SetPref( gNameRight, "gNameRight", "seqprint");
  2561.     gApplication->SetPref( gIndexLeft, "gIndexLeft", "seqprint");
  2562.     gApplication->SetPref( gIndexRight, "gIndexRight", "seqprint");
  2563.     gApplication->SetPref( gIndexTop, "gIndexTop", "seqprint");
  2564.     gApplication->SetPref( gColored, "gColored", "seqprint");
  2565.     gApplication->SetPref( gBasesPerLine, "gBasesPerLine", "seqprint");
  2566.     
  2567. // restrict map
  2568.     gApplication->SetPref( gShowComplement, "gShowComplement", "seqprint");
  2569.     gApplication->SetPref( gThreeLetAA, "gThreeLetAA", "seqprint");
  2570.     gApplication->SetPref( gOnlyORF, "gOnlyORF", "seqprint");
  2571.     
  2572.     gApplication->SetPref( gShowAA1, "gShowAA1", "seqprint");
  2573.     gApplication->SetPref( gShowAA2, "gShowAA2", "seqprint");
  2574.     gApplication->SetPref( gShowAA3, "gShowAA3", "seqprint");
  2575.     gApplication->SetPref( gShowCompAA1, "gShowCompAA1", "seqprint");
  2576.     gApplication->SetPref( gShowCompAA2, "gShowCompAA2", "seqprint");
  2577.     gApplication->SetPref( gShowCompAA3, "gShowCompAA3", "seqprint");
  2578.  
  2579. // rest. map tables
  2580.     gApplication->SetPref( gShowAllZymes, "gShowAllZymes", "remap");
  2581.     gApplication->SetPref( gShowCutpoints, "gShowCutpoints", "remap");
  2582.     gApplication->SetPref( gShowNoncutters, "gShowNoncutters", "remap");
  2583.     gApplication->SetPref( gShowExcludedCutters, "gShowExcludedCutters", "remap");
  2584.     gApplication->SetPref( gREMinCuts, "gREMinCuts", "remap");
  2585.     gApplication->SetPref( gREMaxCuts, "gREMaxCuts", "remap");
  2586.  
  2587. }
  2588.  
  2589.  
  2590.  
  2591.  
  2592. void DSeqPrintPrefs::NewFontCluster(char* title, DView* mainview,
  2593.                     DPopupMenu*& mfont, DPopupMenu*& mstyle, DSwitchBox*& swsize,
  2594.                     char* fontname, short fontstyle, short fontsize )
  2595. {    
  2596.         // Name style -- font, font size, font style
  2597.     DPopupMenu* popm;
  2598.     DSwitchBox* sw;
  2599.     DPrompt* pr;
  2600.     DView* super;
  2601.     
  2602.     super= mainview;
  2603.     super->NextSubviewBelowLeft();
  2604.  
  2605.     DCluster* maincluster= new DCluster( 0, super, 30, 10, true, NULL); //false, title);
  2606.     super= maincluster;
  2607.  
  2608.     popm= new DPopupMenu( 0, (Nlm_GrouP)super->GetNlmObject(), "Font  ");
  2609.     mfont= popm;
  2610.     popm->AddFonts();
  2611.     popm->SetFontChoice( fontname); 
  2612.     //super->NextSubviewToRight();
  2613.  
  2614.     popm= new DPopupMenu( 0, (Nlm_GrouP)super->GetNlmObject(), "Style  ");
  2615.     mstyle= popm;
  2616.     popm->AddItem( kStylePlain, "Plain", true);
  2617.     popm->AddItem( kStyleItalic, "Italic", true);
  2618.     popm->AddItem( kStyleBold, "Bold", true);
  2619.     popm->AddItem( kStyleUnderline, "Underline", true);
  2620.     popm->SetItemStatus( kStylePlain, fontstyle==0);
  2621.     popm->SetItemStatus( kStyleItalic, fontstyle & kItalic);
  2622.     popm->SetItemStatus( kStyleBold, fontstyle & kBold);
  2623.     popm->SetItemStatus( kStyleUnderline, fontstyle & kUnderline);
  2624.     //super->NextSubviewToRight();
  2625.     
  2626.     DCluster* cluster= new DCluster(0, super, 30, 10, true, NULL);
  2627.     super= cluster;
  2628.     
  2629.     pr= new DPrompt( 0, super, "font size", 0, 0, Nlm_programFont);             
  2630.     //super->NextSubviewToRight();
  2631.     super->NextSubviewBelowLeft();
  2632.     sw = new DSwitchBox(0, super, true, true);
  2633.     swsize= sw;
  2634.     sw->SetValues(fontsize,99);
  2635.     //super->NextSubviewBelowLeft();
  2636.  
  2637.     super= mainview;
  2638.     super->NextSubviewBelowLeft();
  2639. }
  2640.  
  2641.  
  2642. void DSeqPrintPrefs::Initialize() 
  2643. { 
  2644.     DView* super;
  2645.     DPrompt* pr;
  2646.     DCheckBox* ck;
  2647.     DCluster* clu;
  2648.     char nums[128];    
  2649.  
  2650.     super= this;
  2651.     clu= new DCluster( 0, super, 30, 10, false, "Bases");
  2652.     super= clu;
  2653.  
  2654.     NewFontCluster( "Base style", super, fBaseFontMenu, fBaseStyleMenu, fBaseSizeSw,
  2655.                             gBaseFontName, gBaseStyle, gBaseFontSize);
  2656.  
  2657.     ck= new DCheckBox(cColored, super, "Color ");
  2658.     ck->SetStatus(gColored);
  2659.     super->NextSubviewToRight();
  2660.     
  2661.     sprintf( nums, "%d", gBasesPerLine);
  2662.     fBasePerLine= new DEditText( 0, super, nums, 4, Nlm_programFont); 
  2663.     this->SetEditText( fBasePerLine);
  2664.     super->NextSubviewToRight();
  2665.     pr= new DPrompt( 0, super, "bases/line", 0, 0, Nlm_programFont);             
  2666.  
  2667.     super = this;
  2668.     //super->NextSubviewToRight();
  2669.     //super->NextSubviewBelowLeft();
  2670.  
  2671.     clu= new DCluster( 0, super, 30, 10, false, "Indices");
  2672.     super= clu;
  2673.  
  2674.     NewFontCluster( "Index style", super, fIndexFontMenu, fIndexStyleMenu, fIndexSizeSw,
  2675.                             gIndexFontName, gIndexStyle, gIndexFontSize);
  2676.  
  2677.     ck= new DCheckBox(cIndexLeft, super, "Left");
  2678.     ck->SetStatus(gIndexLeft);
  2679.     ck= new DCheckBox(cIndexRight, super, "Right");
  2680.     ck->SetStatus(gIndexRight);
  2681.     ck= new DCheckBox(cIndexTop, super, "Top");
  2682.     ck->SetStatus(gIndexTop);
  2683.  
  2684.     super = this;
  2685.     //super->NextSubviewToRight();
  2686.     //super->NextSubviewBelowLeft();
  2687.  
  2688.     clu= new DCluster( 0, super, 30, 10, false, "Names");
  2689.     super= clu;
  2690.  
  2691.     NewFontCluster( "Name style", super, fNameFontMenu, fNameStyleMenu, fNameSizeSw,
  2692.                             gNameFontName, gNameStyle, gNameFontSize);
  2693.  
  2694.     ck= new DCheckBox(cNameLeft, super, "Left");
  2695.     ck->SetStatus(gNameLeft);
  2696.     ck= new DCheckBox(cNameRight, super, "Right");
  2697.     ck->SetStatus(gNameRight);
  2698.     
  2699.     super = this;
  2700.     //super->NextSubviewToRight();
  2701.     //super->NextSubviewBelowLeft();
  2702.  
  2703. #if 1        
  2704.  
  2705.                 // turn this into 2nd dialog window...
  2706.                 
  2707.     clu= new DCluster( 0, super, 30, 10, false, "Restriction Maps");
  2708.     super= clu;
  2709.  
  2710.     ck= new DCheckBox(cShowComplement, super, "Show Complement");
  2711.     ck->SetStatus(gShowComplement);
  2712.     super->NextSubviewBelowLeft();
  2713.     
  2714.     DCluster* pclu= new DCluster( 0, super, 30, 10, false, "Protein translate frame");
  2715.     super= pclu;
  2716.     pr= new DPrompt( 0, super, " sequence", 0, 0, Nlm_programFont);             
  2717.     super->NextSubviewToRight();
  2718.     ck= new DCheckBox(cShowAA1, super, "1st");
  2719.     ck->SetStatus(gShowAA1);
  2720.     super->NextSubviewToRight();
  2721.     ck= new DCheckBox(cShowAA2, super, "2nd");
  2722.     ck->SetStatus(gShowAA2);
  2723.     super->NextSubviewToRight();
  2724.     ck= new DCheckBox(cShowAA3, super, "3rd");
  2725.     ck->SetStatus(gShowAA3);
  2726.     super->NextSubviewBelowLeft();
  2727.  
  2728.     pr= new DPrompt( 0, super, "complement", 0, 0, Nlm_programFont);             
  2729.     super->NextSubviewToRight();
  2730.     ck= new DCheckBox(cShowCompAA1, super, "1st");
  2731.     ck->SetStatus(gShowCompAA1);
  2732.     super->NextSubviewToRight();
  2733.     ck= new DCheckBox(cShowCompAA2, super, "2nd");
  2734.     ck->SetStatus(gShowCompAA2);
  2735.     super->NextSubviewToRight();
  2736.     ck= new DCheckBox(cShowCompAA3, super, "3rd");
  2737.     ck->SetStatus(gShowCompAA3);
  2738.  
  2739.     super->NextSubviewBelowLeft();
  2740.     ck= new DCheckBox(cThreeLetAA, super, "3-letter code");
  2741.     ck->SetStatus(gThreeLetAA);
  2742.     super->NextSubviewToRight();
  2743.     ck= new DCheckBox(cOnlyORF, super, "ORFs only");
  2744.     ck->SetStatus(gOnlyORF);
  2745.     super= clu;
  2746.     super->NextSubviewBelowLeft();
  2747.  
  2748.     DCluster* rclu= new DCluster( 0, super, 30, 10, false, "Restriction enzymes");
  2749.     super= rclu;
  2750.  
  2751.     pr= new DPrompt( 0, super, "Min. cuts", 0, 0, Nlm_programFont);             
  2752.     super->NextSubviewToRight();
  2753.     sprintf( nums, "%d", gREMinCuts);
  2754.     fREMinCuts= new DEditText( 0, super, nums, 4, Nlm_programFont); 
  2755.     this->SetEditText( fREMinCuts);
  2756.     pr= new DPrompt( 0, super, "Max. cuts", 0, 0, Nlm_programFont);             
  2757.     super->NextSubviewToRight();
  2758.     sprintf( nums, "%d", gREMaxCuts);
  2759.     fREMaxCuts= new DEditText( 0, super, nums, 4, Nlm_programFont); 
  2760.     super->NextSubviewBelowLeft();
  2761.  
  2762.     pr= new DPrompt( 0, super, "Tables", 0, 0, Nlm_programFont);             
  2763.     super->NextSubviewToRight();
  2764.     ck= new DCheckBox(cShowCutpoints, super, "Cutpoints");
  2765.     ck->SetStatus(gShowCutpoints);
  2766.     ck= new DCheckBox(cShowAllZymes, super, "All zymes");
  2767.     ck->SetStatus(gShowAllZymes);
  2768.     super->NextSubviewBelowLeft();
  2769.     ck= new DCheckBox(cShowNoncutters, super, "Noncutters");
  2770.     ck->SetStatus(gShowNoncutters);
  2771.     ck= new DCheckBox(cShowExcludedCutters, super, "Excluded cutters");
  2772.     ck->SetStatus(gShowExcludedCutters);
  2773.  
  2774.     super= clu;
  2775.  
  2776.     super= this;
  2777. #endif
  2778.  
  2779.     this->AddOkayCancelButtons();
  2780.     
  2781. }
  2782.  
  2783.  
  2784. void DSeqPrintPrefs::OkayAction() 
  2785. { 
  2786.     short             aSize, aStyle;
  2787.     char            name[256], *nums;
  2788.     DMenu     *    aFontMenu, * aStyleMenu;
  2789.     Nlm_FonT    aFont;
  2790.     
  2791.     if (fREMinCuts) {
  2792.         nums= fREMinCuts->GetTitle(name, sizeof(name));
  2793.         gREMinCuts= atol(nums);
  2794.         }
  2795.     if (fREMaxCuts) {
  2796.         nums= fREMaxCuts->GetTitle(name, sizeof(name));
  2797.         gREMaxCuts= atol(nums);
  2798.         }
  2799.     if (fBasePerLine) {
  2800.         nums= fBasePerLine->GetTitle(name, sizeof(name));
  2801.         gBasesPerLine= atol(nums);
  2802.         }
  2803.     
  2804.     for (short imenu= 0; imenu<3; imenu++) {
  2805.         
  2806.         switch (imenu) {
  2807.           case 0:
  2808.                 aFontMenu= fNameFontMenu; 
  2809.                 aStyleMenu= fNameStyleMenu; 
  2810.                 aSize= fNameSizeSw->GetValue();// aSize= gNameFontSize;
  2811.               break;
  2812.           case 1:
  2813.                 aFontMenu= fBaseFontMenu; 
  2814.                 aStyleMenu= fBaseStyleMenu; 
  2815.                 aSize= fBaseSizeSw->GetValue();// aSize= gBaseFontSize;
  2816.               break;
  2817.           case 2:
  2818.                 aFontMenu= fIndexFontMenu; 
  2819.                 aStyleMenu= fIndexStyleMenu; 
  2820.                 aSize= fIndexSizeSw->GetValue();// aSize= gIndexFontSize;
  2821.               break;
  2822.           }
  2823.             
  2824.         if (aFontMenu && aFontMenu->GetFontChoice(name, sizeof(name))) {
  2825.             aStyle= 0;
  2826. #ifdef WIN_MAC
  2827.             if (!aStyleMenu->GetItemStatus(kStylePlain)) {
  2828.                 if (aStyleMenu->GetItemStatus(kStyleItalic   )) aStyle |= kItalic;
  2829.                 if (aStyleMenu->GetItemStatus(kStyleBold     )) aStyle |= kBold;
  2830.                 if (aStyleMenu->GetItemStatus(kStyleUnderline)) aStyle |= kUnderline;
  2831.                 }
  2832. #else
  2833.              short item= Nlm_GetValue(((DPopupMenu*)aStyleMenu)->fPopup);
  2834.              switch (item) {
  2835.                  case 1: aStyle= 0; break;
  2836.                  case 2: aStyle |= kItalic; break;
  2837.                  case 3: aStyle |= kBold; break;
  2838.                  case 4: aStyle |= kUnderline; break;
  2839.          }
  2840. #endif             
  2841.             if (StringCmp(name,"System")==0) aFont= Nlm_systemFont;
  2842.             else if (StringCmp(name,"Program")==0) aFont= Nlm_programFont;
  2843.             else aFont= Nlm_GetFont( name, aSize, aStyle & kBold, 
  2844.                                                     aStyle & kItalic, aStyle & kUnderline, NULL);
  2845.             
  2846.             switch (imenu) {
  2847.               case 0: 
  2848.               if (aSize != gNameFontSize || aStyle != gNameStyle || StringCmp(name,gNameFontName)!=0) {
  2849.                     if (gNameFontName) MemFree(gNameFontName);
  2850.                     gNameFontName= StrDup(name);
  2851.                     gNameFont= aFont;
  2852.                     gNameFontSize= aSize;
  2853.                     gNameStyle= aStyle;
  2854.                     fNeedSave= true;
  2855.                     }
  2856.                   break;
  2857.                   
  2858.               case 1: 
  2859.               if (aSize != gBaseFontSize || aStyle != gBaseStyle || StringCmp(name,gBaseFontName)!=0) {
  2860.                     if (gBaseFontName) MemFree(gBaseFontName);
  2861.                     gBaseFontName= StrDup(name);
  2862.                     gBaseFont= aFont;
  2863.                     gBaseFontSize= aSize;
  2864.                     gBaseStyle= aStyle;
  2865.                     fNeedSave= true;
  2866.                     }
  2867.                   break;
  2868.                   
  2869.               case 2: 
  2870.               if (aSize != gIndexFontSize || aStyle != gBaseStyle || StringCmp(name,gIndexFontName)!=0) {
  2871.                     if (gIndexFontName) MemFree(gIndexFontName);
  2872.                     gIndexFontName= StrDup(name);
  2873.                     gIndexFont= aFont;
  2874.                     gIndexFontSize= aSize;
  2875.                     gIndexStyle= aStyle;
  2876.                     fNeedSave= true;
  2877.                     }
  2878.                   break;
  2879.               }
  2880.               
  2881.             }
  2882.         }
  2883.     
  2884. #if 0
  2885. #if 1
  2886.     // CurrentWindow gets prefs dlog window, not one we want    
  2887.     //DSeqPrintDoc* awin= (DSeqPrintDoc*) gWindowManager->CurrentWindow();
  2888.     DList* wins= gWindowManager->GetWindowList();
  2889.     if (wins) {
  2890.         short last1= wins->GetSize() - 2;
  2891.         if (last1>0) {
  2892.             DSeqPrintDoc* awin= (DSeqPrintDoc*) wins->At(last1);
  2893.             if (awin && awin->Id() == DSeqPrintDoc::kSeqPrintDoc) {
  2894.                 awin->fView->Initialize();
  2895.                 awin->fView->GetReadyToShow();
  2896.                 awin->fView->Invalidate();
  2897.                 }
  2898.             }
  2899.         }
  2900. #else    
  2901.     DList* wins= gWindowManager->GetWindowList();
  2902.     if (wins) {
  2903.         long i, nwin= wins->GetSize();
  2904.         for (i= nwin-1; i>=0; i--) {
  2905.             DSeqPrintDoc* awin= (DSeqPrintDoc*) wins->At(i);
  2906.             if (awin && awin->Id() == DSeqPrintDoc::kSeqPrintDoc) {
  2907.                 awin->fView->Initialize();
  2908.                 awin->fView->GetReadyToShow();
  2909.                 awin->fView->Invalidate();
  2910.                 break; // do only 1st we find ...
  2911.                 }
  2912.             }
  2913.         }
  2914. #endif        
  2915. #endif
  2916.  
  2917. }
  2918.  
  2919.  
  2920.  
  2921. Boolean DSeqPrintPrefs::IsMyAction(DTaskMaster* action) 
  2922. {    
  2923.     DView* aview= (DView*) action;
  2924.     
  2925.     switch (action->Id()) {
  2926.  
  2927.         case cIndexLeft : gIndexLeft= aview->GetStatus(); break;
  2928.         case cIndexRight: gIndexRight= aview->GetStatus(); break;
  2929.         case cIndexTop  : gIndexTop= aview->GetStatus(); break;
  2930.         case cNameLeft    : gNameLeft= aview->GetStatus(); break;
  2931.         case cNameRight    : gNameRight= aview->GetStatus(); break;
  2932.         case cColored        : gColored= aview->GetStatus(); break;
  2933.  
  2934.         case cShowComplement: gShowComplement= aview->GetStatus(); break;
  2935.         case cThreeLetAA    : gThreeLetAA= aview->GetStatus(); break;
  2936.         case cOnlyORF    : gOnlyORF= aview->GetStatus(); break;
  2937.         case cShowAA1    : gShowAA1= aview->GetStatus(); break;
  2938.         case cShowAA2    : gShowAA2= aview->GetStatus(); break;
  2939.         case cShowAA3    : gShowAA3= aview->GetStatus(); break;
  2940.         case cShowCompAA1    : gShowCompAA1= aview->GetStatus(); break;
  2941.         case cShowCompAA2    : gShowCompAA2= aview->GetStatus(); break;
  2942.         case cShowCompAA3    : gShowCompAA3= aview->GetStatus(); break;
  2943.         case cShowCutpoints    : gShowCutpoints= aview->GetStatus(); break;
  2944.         case cShowAllZymes    : gShowAllZymes= aview->GetStatus(); break;
  2945.         case cShowNoncutters    : gShowNoncutters= aview->GetStatus(); break;
  2946.         case cShowExcludedCutters    : gShowExcludedCutters= aview->GetStatus(); break;
  2947.  
  2948.         default : return DWindow::IsMyAction(action);    
  2949.         }
  2950.         
  2951.     fNeedSave= true;
  2952.     return true;
  2953. }
  2954.  
  2955.  
  2956. void DSeqPrintPrefs::Open()
  2957. {
  2958.     DWindow::Open();
  2959. }
  2960.  
  2961. void DSeqPrintPrefs::Close()
  2962. {
  2963.     if (fNeedSave) {
  2964.         DSeqPrintPrefs::SaveGlobals();
  2965.         fNeedSave= false;
  2966.         }
  2967.     DWindow::Close();
  2968. }
  2969.  
  2970.  
  2971.  
  2972.     // global calling function
  2973. void SeqPrintPrefs(short id)
  2974. {
  2975.     switch (id) {
  2976.     
  2977.         case kSeqPrintPrefInit: 
  2978.             DSeqPrintPrefs::InitGlobals(); 
  2979.             break;
  2980.     
  2981.         case kSeqPrintPrefDialog:
  2982.             if (!gSeqPrintPrefs) {
  2983.                 gSeqPrintPrefs = new DSeqPrintPrefs();
  2984.                 gSeqPrintPrefs->Initialize();
  2985.                 }
  2986.             if (gSeqPrintPrefs && gSeqPrintPrefs->PoseModally()) ;
  2987.             break;
  2988.             
  2989.         case kAlnPrintPrefDialog:
  2990.         case kREMapPrefDialog:
  2991.             break;
  2992.     }
  2993.     
  2994. }
  2995.  
  2996.  
  2997.